目录
本章内容
~ 认识进程
~ 认识多线程
~ 掌握多线程程序的编写
~ 并发线程编程如何提高程序的效率
~ Thread类具体的用法(所包含的一些属性和方法)
前言
认识进程~
操作系统(OS)软件~
进程(也叫任务)~
关于进程,最核心的问题,就是进程在系统中是如何被管理的?
PCB中大概有哪些属性?
并发执行
并行式运行
进程的状态
进程的优先级
进程的上下文
进程的记账信息
进程的虚拟空间
认识多线程
掌握多线程程序的编写
线程的创建还有很多方式:
并发线程编程如何提高程序的效率
串行执行:
Thread类具体的用法(所包含的一些属性和方法 )
本章内容
~ 认识进程
~ 认识多线程
~ 掌握多线程程序的编写
~ 并发线程编程如何提高程序的效率
~ Thread类具体的用法(所包含的一些属性和方法)
前言
~ 掌握多线程程序的编写
~ 并发线程编程如何提高程序的效率
~ Thread类具体的用法(所包含的一些属性和方法)
前言
~ Thread类具体的用法(所包含的一些属性和方法)
前言
认识进程~
在了解什么是线程之前我们必须要知道什么是进程.
说到进程就要说到我们的操作系统
操作系统(OS)软件~
操作系统是一个"搞管理"的软件
1.管理硬件设备
2.管理软件资源(比如说文件,进程)
所谓的管理:两个方面:描述+组织
进程(也叫任务)~
操作系统中一个非常非常核心的概念
"进程"其实是计算机完成一个工作的"过程"
说的通俗点:进程就是一个"正在运行"的程序
要想让进程跑起来,就得给这个进程分配一定的系统硬件资源:CPU,内存,磁盘,网络带宽......
进程是系统分配资源的基本单位
关于进程,最核心的问题,就是进程在系统中是如何被管理的?
管理 = 描述(PCB) + 组织
PCB:进程控制块,这是一个类/C语言的结构体,一个结构体对象就对应一个进程
组织:使用一定的数据结构来组织(一种常见的做法就是使用双链表)
查看进程列表,本质上就是遍历操作系统内核中的这个链表并显示其中的属性
创建一个进程,本质上就是创建一个PCB对象,加入到内核的链表中
销毁一个进程,本质上就是把这个PCB对象从内核链表中删除掉
PCB中大概有哪些属性?
pid:一个进程的的身份标识,一个机器同一时刻,不可能有两个进程的pid相同
内存指针:描述了这个进程都打开了哪些文件(系统中打开了一个文件,其实就是得到了一个文件描述符)
文件描述符:描述了这个进程都打开了哪些文件(系统中打开了一个文件,其实就得到了一个"文件描述符")
进程的状态
进程的优先级
进程的上下文
进程的记账信息
这几个很关键~用来辅助进行"进程调度"的!!!
大家可以打开看一下自己的电脑,正常情况下每台电脑上都有上百个进程在运行
那电脑上有几个CPU呢?
1个CPU(8 core CPU)
多核的意思就是把CPU捆绑在一起了
8 core就相当于CPU有8个分身,能同时干活
现在的电脑都支持这种多任务系统
当前的这个"多任务系统"其实就是基于进程调度这样的机制来完成的~
操作系统就是这么管理进程的
并发执行
运行第一个进程运行一会再运行第二个,第二个运行一会再运行第三个,以此运行.
由于CPU的运行速度极快,虽然CPU一直进行切换,但是咱们坐在电脑前的用户,是感知不到这个切换的过程的~~
并行式运行
多个CPU,运行多个进程
如:CPU1运行进程1,CPU2运行进程2
进程1和进程2无论是微观还是宏观,都是同时执行的
真是的计算机,真实的操作系统在进行进程调度的时候,是并发并行两种策略综合使用的
进程的状态
指的是当前的这个进程是:
就绪状态(随时能够去CPU执行)
睡眠状态(进程要等待用户的输入,就好比qq对话框,你要输入内容,单系统不知道你要什么时候输入,所以系统就让这个进程去等待,等待用户输入之后才能继续往下执行)
结束状态:(进程被关闭)
进程的状态不单单指这几种,其他的就不详细列举了
进程的优先级
安排时间表的时候,优先给谁安排?
好比周一到周六我要安排时间表,分为12块时间~
这12块时间不一定均匀分配
进程的上下文
需要记住上次运行到哪个指令了,方便下次调度的时候能够继续从这个位置来运行
相当于单机游戏的(存档和读档)
进程的上下文,主要是存储调度出CPU之前,寄存器中的信息(把寄存器信息保存到内存中)
进程本身是感知不到自己是啥时候被调度出CPU的
进程的记账信息
记录这个进程在CPU上执行了多久了,用来辅助决定这个进程是继续在CPU上执行,还是说要调度出去了
这个进程调度的过程,是非常非常重要的!!!
对于咱们后面写代码来说有很大的指导意义.
操作系统何时进行进程调度(啥时候把进程放到CPU上,啥时候把进程切换出CPU)这个事情对于进程本身来说,是感知不到的(抢占式执行)
执行到进程中的任意指令,都可能随时产生这样的调度.此时,这样的调度其实给我们的代码引入了一定的随机性,对于我们代码的正确性来说,就产生了新的挑战
进程的虚拟空间
一个进程要想运行,就需要给它分配一些系统资源,其中内存就是一个最核心的资源
物理地址:真实的内存地址
原始计算机是如何分配资源给进程的:
虚拟地址空间:
现在的计算机是如何分配资源给进程的:
认识多线程
进入进程的目的,就是为了能够"并发编程"
虽然进程已经能够解决并发的问题了,但是我们认为还不够理想
创建进程/销毁进程/调度进程,开销有点太大了
进程是系统资源分配的基本单位
创建进程,就需要分配资源
销毁进程,就需要释放资源
如果频繁创建销毁,这样的开销就比较大了
于是程序猿就发明了一个"线程(Thread)"概念,线程在有些系统上也叫做"轻量级进程"
轻量:
创建线程比创建进程更高效
销毁线程比销毁进程更高效
调度线程也比调度进程更高效
为什么更高效?
创建线程,并没有去申请资源
销毁线程,也不需要释放资源
没资源如何工作呢?
让线程产生在进程内部,共用之前的资源
进程和线程之间,是包含关系
一个进程可以包含一个线程或者多个线程
先把之前进程创建出来之后,这个时候,相当于资源都分配好了
然后在这个进程里面,创建线程.
这样线程就和之前的进程共用一样的资源了
站在系统内核的角度,再来看待进程和线程
进程和线程之间的区别和联系(经典面试题)
1.进程是包含线程的,一个进程里面可以有一个线程,也可以有多个线程
2.每个进程都有独立的内存空间(虚拟地址空间),同一个进程的多个线程之间,共用这个虚拟地址空间
3.进程是操作系统资源分配的基本单位,线程是操作系统调度执行的基本单位
上面所介绍的"进程调度"当时是没考虑线程的,实际上系统是以线程为单位进程调度(以PCB为单位进行调度)
一个简单的例子:吃鸡
掌握多线程程序的编写
使用Java来操作线程
在Java中,使用Thread这个类的对象来表示一个操作系统中的线程
PCB是在操作系统内核中,描述线程的
Thread类是在咱们Java中描述线程的
//Thread是 Java 标准库中描述一个关于线程的类
//常用的方法就是自己定义一个类继承 Thread
//重写 Thread 中的 run 方法. run方法就是表示线程要执行的具体任务(代码).
class MyThread extends Thread{
@Override
public void run() {
System.out.println("hello,Thread");
}
}
public class Test {
public static void main(String[] args) {
Thread thread = new MyThread();
//stat 方法,就会在操作系统中真的创建一个线程出来,(内核中搞个PCB,加入到双链表中)
//这个新的线程,就会执行 run中所描述的代码
thread.start();
thread.run()
}
}
thread.strat()和thread.run()的区别(经典面试题)
换一种写法:
class MyThread1 extends Thread{
//1.
@Override
public void run() {
while(true){
System.out.println("hello,Thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
public class TestDome {
//2.
public static void main(String[] args) {
Thread t = new MyThread1();
t.start();
while (true){
System.out.println("hello,main");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
新线程MyThread1里面是一个死循环,会一直循环执行.main函数主线程里面也会一直循环执行.都是死循环,这两个代码能够同时执行吗
按照现在的说法是可以同时执行的
因为1是一个执行流
2也是一个执行流
他俩之间是并发的关系
运行程序观察结果:
此时可以看到这俩逻辑都在执行,在交替打印
通过刚才的代码我们就可以看到通过这样的一个线程就可以让这两个死循环能够按照并发的方式一起来去跑.而不是说单纯的执行完一个再去执行下一个
这是通过start创建线程来这么做的
如果把start改成run呢?
我们看一下:
class MyThread1 extends Thread{
@Override
public void run() {
while(true){
System.out.println("hello,Thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
public class TestDome {
public static void main(String[] args) {
Thread t = new MyThread1();
//t.start();
t.run();
while (true){
System.out.println("hello,main");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
如果改成run的话就是一个线程内部来完成两个循环了
执行到run循环里面之后就会打印"hello,Thread",因为是死循环所以下面的循环就不会执行
运行程序观察结果:
线程的创建还有很多方式:
1.就是上面我们举例的这种方式通过继承THread,重写 run.
2.实现Runnable接口,重写 run方法.
我们写一下第二种方式
标准库提供的一个接口
字面意思"可运行的"
这个接口主要用于描述"一个任务"
通过run方法来描述具体要执行的代码是啥~~
class MyThread2 implements Runnable{
@Override
public void run() {
while(true){
System.out.println("hello,Thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
public class TestDome2 {
public static void main(String[] args) {
//注意:Runnable并不能够独立去使用,要搭配Thread类来使用
Thread t = new Thread(new MyThread2());
t.start();
}
}
观察运行结果:
第三种方式:
继承Thread,重写 run,使用匿名内部类的方式
内部类:在一个类里面定义类
匿名内部类:一个没有类名的内部类
没有类名没关系,至少可以创建出一个实例来~
什么时候需要使用匿名内部类:只需要用这个实例,不需要用其他实例了
public class TestDemo3 {
public static void main(String[] args) {
//这个语法就是匿名内部类
//相当于是创建了一个匿名的类,这个类继承了 Thread.
//此处咱们 new 的实例,其实是 new 了这个新的子类的实例
Thread t = new Thread(){
@Override
public void run() {
while(true){
System.out.println("hello,thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
};
t.start();
}
}
这种写法,本质上和单独创建一个类,再继承 Thread 是没区别的
第三种写法和第一种写法本质上没有区别,只不过第三种写法写起来更简单一点~
我们把这种写法称为(语法糖)
这种写法习惯了之后可读性是并不低~~
比较悲伤的是,Java里面方法不能脱离类存在
所以才有匿名内部类和这种稍微复杂一点的写法
第四种写法:
实现Runnable,重写run,使用匿名内部类~
public class TestDome4 {
public static void main(String[] args) {
Thread t = new Thread(new Runnable(){
@Override
public void run() {
System.out.println("hello,Thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
}
}
第五种写法:适用lambda表达式来表示要执行的任务~
lambda:很多语言都有lambda,本质上是一个匿名函数
public class TestDome5 {
public static void main(String[] args) {
Thread t = new Thread(() ->{
while (true){
System.out.println("hello,Thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
t.start();
}
}
lambda表达式,是直接了当的指定这样的任务~~
以上这些创建线程的方式,本质都相同
都是借助Thread类,在内核中创建新的PCB,加入到内核的双向链表中......
只不过区别是,指定线程要执行的任务方式不一样.
此处的区别,其实都只是单纯的java语法层面的区别~
能否更明显的看到有新的线程出来?
在JDK中内置了一个jconsole工具~
就可以看到线程的信息~
(IDEA也能看到)
并发线程编程如何提高程序的效率
具体效率怎么提高的?能提高多少我们看下面代码:
我们先看这个数字:
我们在写一个比较大的字面值常量的时候,如果0太多了
就容易数不清.建议使用下划线来做出分割
我们可以试一下分别是并发的方式,串行的方式
比如现在有个变量a和b
循环的对于a自增10亿次
循环的对于b也自增10亿次
分别通过串行的方式和并发(多线程),执行~
串行执行:
public class Test {
private static final long count = 10_0000_0000L;
//串行的来针对 a 和 b 进行自增
//serial意为串行
public static void serial(){
//System.currentTimeMillis()获取到当前系统的毫秒级时间戳
long beg = System.currentTimeMillis();
int a = 0;
for (long i = 0; i < count ; i++) {
a++;
}
int b = 0;
for (long i = 0; i
打印结果:
大概时间是1.5秒左右
并发式执行:
public class Test {
private static final long count = 10_0000_0000L;
public static void concurrency(){
long beg = System.currentTimeMillis();
Thread t1 = new Thread(){
@Override
public void run() {
int a = 0;
for (long i = 0; i < count ; i++) {
a++;
}
}
};
t1.start();
Thread t2 = new Thread(){
@Override
public void run() {
int b = 0;
for (long i = 0; i
打印结果:
大概时间是0.7秒左右
串行执行:1500 - 1700毫秒左右
并发执行 800 - 900毫秒左右
速度确实是提高了!!
是正好提高一倍嘛?
不是
不一定
线程调度,自身也是有开销的~~
一个线程执行了20亿次循环.
中间可能会调度若干次(调度时间会花一定的时间)
现在是两个线程各自执行10亿次循环.
中间也可能会调度若干次(也会花一定的时间)
这两组调度的时间具体是多少,完全不确定
Thread类具体的用法(所包含的一些属性和方法 )
Thread 的 name,存在的意义就是为了方便调试~~
如果线程多了,就容易弄混~
给线程起一个名字之后,调试的时候就可以很清楚的看到当前的线程谁是谁
public class TestDome {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
while (true) {
System.out.println("hello,thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
},"mythread");
t.start();
}
}
在代码里面我们给线程的构造方法中传入了一个名字,如实我们创建出来的线程就带有这个名字
写代码的时候一定要关注程序是不是方便调试
如何在IDEA中给变量/方法/类重命名??
shift + f6
重命名会把所有有关联的代码都自动进行修改
此处说的是线程的状态,和上节课的"进程状态"是类似的效果.
存在的意义都是辅助进行线程调度
优先级也就和上节课"进程的优先级"是类似的效果.
此处的状态和优先级,和内核PCB中的状态优先级并不完全一致
创建的一个线程,默认不是后台线程
此时,如果main方法结束了,线程还没结束,JVM进程不会结束
如果当前线程是后台线程
此时,如果main方法结束了,线程还没有结束,JVM进程就会直接结束,同时也就把这个后台线程也一起带走了
(是否是后台线程,影响了JVM进程是否能够退出)
内核中的PCB是不是销毁了(系统中线程是不是销毁了)
1
2
3
我们通过代码看一下Thread的这些属性和方法
public class TestDome1 {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
while (true){
//打印当前线程的名字
//Thread.currentThread()这个静态方法,获取到当前线程实例
//哪个线程调用这个方法,就能获取到当前线程实例
System.out.println(Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
},"myThread");
t.start();
//在这里也打印一下这个线程的属性
System.out.println("id: " + t.getId() );
System.out.println("name: " + t.getName());
System.out.println("state: " + t.getState());
System.out.println("priority: " + t.getPriority());
System.out.println("isDaemon" + t.isDaemon());
System.out.println("isInterrupted: "+t.isInterrupted());
System.out.println("isAlive " + t.isAlive());
}
我们先看一下线程没跑起来的信息:
state,这个状态是NEW,这个状态就表示Thread对象有了,但是PCB还没有创建
isAlive:false:当前的PCB是没有的
线程跑起来的信息:
isAlive:true:表示PCB已经有了
state:RUNNABLE
在了解什么是线程之前我们必须要知道什么是进程.
说到进程就要说到我们的操作系统
操作系统(OS)软件~
操作系统是一个"搞管理"的软件
1.管理硬件设备
2.管理软件资源(比如说文件,进程)
所谓的管理:两个方面:描述+组织
进程(也叫任务)~
操作系统中一个非常非常核心的概念
"进程"其实是计算机完成一个工作的"过程"
说的通俗点:进程就是一个"正在运行"的程序
要想让进程跑起来,就得给这个进程分配一定的系统硬件资源:CPU,内存,磁盘,网络带宽......
进程是系统分配资源的基本单位
关于进程,最核心的问题,就是进程在系统中是如何被管理的?
管理 = 描述(PCB) + 组织
PCB:进程控制块,这是一个类/C语言的结构体,一个结构体对象就对应一个进程
组织:使用一定的数据结构来组织(一种常见的做法就是使用双链表)
查看进程列表,本质上就是遍历操作系统内核中的这个链表并显示其中的属性
创建一个进程,本质上就是创建一个PCB对象,加入到内核的链表中
销毁一个进程,本质上就是把这个PCB对象从内核链表中删除掉
PCB中大概有哪些属性?
pid:一个进程的的身份标识,一个机器同一时刻,不可能有两个进程的pid相同
内存指针:描述了这个进程都打开了哪些文件(系统中打开了一个文件,其实就是得到了一个文件描述符)
文件描述符:描述了这个进程都打开了哪些文件(系统中打开了一个文件,其实就得到了一个"文件描述符")
进程的状态
进程的优先级
进程的上下文
进程的记账信息
这几个很关键~用来辅助进行"进程调度"的!!!
大家可以打开看一下自己的电脑,正常情况下每台电脑上都有上百个进程在运行
那电脑上有几个CPU呢?
1个CPU(8 core CPU)
多核的意思就是把CPU捆绑在一起了
8 core就相当于CPU有8个分身,能同时干活
现在的电脑都支持这种多任务系统
当前的这个"多任务系统"其实就是基于进程调度这样的机制来完成的~
操作系统就是这么管理进程的
并发执行
运行第一个进程运行一会再运行第二个,第二个运行一会再运行第三个,以此运行.
由于CPU的运行速度极快,虽然CPU一直进行切换,但是咱们坐在电脑前的用户,是感知不到这个切换的过程的~~
并行式运行
多个CPU,运行多个进程
如:CPU1运行进程1,CPU2运行进程2
进程1和进程2无论是微观还是宏观,都是同时执行的
真是的计算机,真实的操作系统在进行进程调度的时候,是并发并行两种策略综合使用的
进程的状态
指的是当前的这个进程是:
就绪状态(随时能够去CPU执行)
睡眠状态(进程要等待用户的输入,就好比qq对话框,你要输入内容,单系统不知道你要什么时候输入,所以系统就让这个进程去等待,等待用户输入之后才能继续往下执行)
结束状态:(进程被关闭)
进程的状态不单单指这几种,其他的就不详细列举了
进程的优先级
安排时间表的时候,优先给谁安排?
好比周一到周六我要安排时间表,分为12块时间~
这12块时间不一定均匀分配
进程的上下文
需要记住上次运行到哪个指令了,方便下次调度的时候能够继续从这个位置来运行
相当于单机游戏的(存档和读档)
进程的上下文,主要是存储调度出CPU之前,寄存器中的信息(把寄存器信息保存到内存中)
进程本身是感知不到自己是啥时候被调度出CPU的
进程的记账信息
记录这个进程在CPU上执行了多久了,用来辅助决定这个进程是继续在CPU上执行,还是说要调度出去了
这个进程调度的过程,是非常非常重要的!!!
对于咱们后面写代码来说有很大的指导意义.
操作系统何时进行进程调度(啥时候把进程放到CPU上,啥时候把进程切换出CPU)这个事情对于进程本身来说,是感知不到的(抢占式执行)
执行到进程中的任意指令,都可能随时产生这样的调度.此时,这样的调度其实给我们的代码引入了一定的随机性,对于我们代码的正确性来说,就产生了新的挑战
进程的虚拟空间
一个进程要想运行,就需要给它分配一些系统资源,其中内存就是一个最核心的资源
物理地址:真实的内存地址
原始计算机是如何分配资源给进程的:
虚拟地址空间:
现在的计算机是如何分配资源给进程的:
进入进程的目的,就是为了能够"并发编程"
虽然进程已经能够解决并发的问题了,但是我们认为还不够理想
创建进程/销毁进程/调度进程,开销有点太大了
进程是系统资源分配的基本单位
创建进程,就需要分配资源
销毁进程,就需要释放资源
如果频繁创建销毁,这样的开销就比较大了
于是程序猿就发明了一个"线程(Thread)"概念,线程在有些系统上也叫做"轻量级进程"
轻量:
创建线程比创建进程更高效
销毁线程比销毁进程更高效
调度线程也比调度进程更高效
为什么更高效?
创建线程,并没有去申请资源
销毁线程,也不需要释放资源
没资源如何工作呢?
让线程产生在进程内部,共用之前的资源
进程和线程之间,是包含关系
一个进程可以包含一个线程或者多个线程
先把之前进程创建出来之后,这个时候,相当于资源都分配好了
然后在这个进程里面,创建线程.
这样线程就和之前的进程共用一样的资源了
站在系统内核的角度,再来看待进程和线程
进程和线程之间的区别和联系(经典面试题)
1.进程是包含线程的,一个进程里面可以有一个线程,也可以有多个线程
2.每个进程都有独立的内存空间(虚拟地址空间),同一个进程的多个线程之间,共用这个虚拟地址空间
3.进程是操作系统资源分配的基本单位,线程是操作系统调度执行的基本单位
上面所介绍的"进程调度"当时是没考虑线程的,实际上系统是以线程为单位进程调度(以PCB为单位进行调度)
一个简单的例子:吃鸡
掌握多线程程序的编写
使用Java来操作线程
在Java中,使用Thread这个类的对象来表示一个操作系统中的线程
PCB是在操作系统内核中,描述线程的
Thread类是在咱们Java中描述线程的
//Thread是 Java 标准库中描述一个关于线程的类
//常用的方法就是自己定义一个类继承 Thread
//重写 Thread 中的 run 方法. run方法就是表示线程要执行的具体任务(代码).
class MyThread extends Thread{
@Override
public void run() {
System.out.println("hello,Thread");
}
}
public class Test {
public static void main(String[] args) {
Thread thread = new MyThread();
//stat 方法,就会在操作系统中真的创建一个线程出来,(内核中搞个PCB,加入到双链表中)
//这个新的线程,就会执行 run中所描述的代码
thread.start();
thread.run()
}
}
thread.strat()和thread.run()的区别(经典面试题)
换一种写法:
class MyThread1 extends Thread{
//1.
@Override
public void run() {
while(true){
System.out.println("hello,Thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
public class TestDome {
//2.
public static void main(String[] args) {
Thread t = new MyThread1();
t.start();
while (true){
System.out.println("hello,main");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
新线程MyThread1里面是一个死循环,会一直循环执行.main函数主线程里面也会一直循环执行.都是死循环,这两个代码能够同时执行吗
按照现在的说法是可以同时执行的
因为1是一个执行流
2也是一个执行流
他俩之间是并发的关系
运行程序观察结果:
此时可以看到这俩逻辑都在执行,在交替打印
通过刚才的代码我们就可以看到通过这样的一个线程就可以让这两个死循环能够按照并发的方式一起来去跑.而不是说单纯的执行完一个再去执行下一个
这是通过start创建线程来这么做的
如果把start改成run呢?
我们看一下:
class MyThread1 extends Thread{
@Override
public void run() {
while(true){
System.out.println("hello,Thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
public class TestDome {
public static void main(String[] args) {
Thread t = new MyThread1();
//t.start();
t.run();
while (true){
System.out.println("hello,main");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
如果改成run的话就是一个线程内部来完成两个循环了
执行到run循环里面之后就会打印"hello,Thread",因为是死循环所以下面的循环就不会执行
运行程序观察结果:
线程的创建还有很多方式:
1.就是上面我们举例的这种方式通过继承THread,重写 run.
2.实现Runnable接口,重写 run方法.
我们写一下第二种方式
标准库提供的一个接口
字面意思"可运行的"
这个接口主要用于描述"一个任务"
通过run方法来描述具体要执行的代码是啥~~
class MyThread2 implements Runnable{
@Override
public void run() {
while(true){
System.out.println("hello,Thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
public class TestDome2 {
public static void main(String[] args) {
//注意:Runnable并不能够独立去使用,要搭配Thread类来使用
Thread t = new Thread(new MyThread2());
t.start();
}
}
观察运行结果:
第三种方式:
继承Thread,重写 run,使用匿名内部类的方式
内部类:在一个类里面定义类
匿名内部类:一个没有类名的内部类
没有类名没关系,至少可以创建出一个实例来~
什么时候需要使用匿名内部类:只需要用这个实例,不需要用其他实例了
public class TestDemo3 {
public static void main(String[] args) {
//这个语法就是匿名内部类
//相当于是创建了一个匿名的类,这个类继承了 Thread.
//此处咱们 new 的实例,其实是 new 了这个新的子类的实例
Thread t = new Thread(){
@Override
public void run() {
while(true){
System.out.println("hello,thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
};
t.start();
}
}
这种写法,本质上和单独创建一个类,再继承 Thread 是没区别的
第三种写法和第一种写法本质上没有区别,只不过第三种写法写起来更简单一点~
我们把这种写法称为(语法糖)
这种写法习惯了之后可读性是并不低~~
比较悲伤的是,Java里面方法不能脱离类存在
所以才有匿名内部类和这种稍微复杂一点的写法
第四种写法:
实现Runnable,重写run,使用匿名内部类~
public class TestDome4 {
public static void main(String[] args) {
Thread t = new Thread(new Runnable(){
@Override
public void run() {
System.out.println("hello,Thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
}
}
第五种写法:适用lambda表达式来表示要执行的任务~
lambda:很多语言都有lambda,本质上是一个匿名函数
public class TestDome5 {
public static void main(String[] args) {
Thread t = new Thread(() ->{
while (true){
System.out.println("hello,Thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
t.start();
}
}
lambda表达式,是直接了当的指定这样的任务~~
以上这些创建线程的方式,本质都相同
都是借助Thread类,在内核中创建新的PCB,加入到内核的双向链表中......
只不过区别是,指定线程要执行的任务方式不一样.
此处的区别,其实都只是单纯的java语法层面的区别~
能否更明显的看到有新的线程出来?
在JDK中内置了一个jconsole工具~
就可以看到线程的信息~
(IDEA也能看到)
并发线程编程如何提高程序的效率
具体效率怎么提高的?能提高多少我们看下面代码:
我们先看这个数字:
我们在写一个比较大的字面值常量的时候,如果0太多了
就容易数不清.建议使用下划线来做出分割
我们可以试一下分别是并发的方式,串行的方式
比如现在有个变量a和b
循环的对于a自增10亿次
循环的对于b也自增10亿次
分别通过串行的方式和并发(多线程),执行~
串行执行:
public class Test {
private static final long count = 10_0000_0000L;
//串行的来针对 a 和 b 进行自增
//serial意为串行
public static void serial(){
//System.currentTimeMillis()获取到当前系统的毫秒级时间戳
long beg = System.currentTimeMillis();
int a = 0;
for (long i = 0; i < count ; i++) {
a++;
}
int b = 0;
for (long i = 0; i
打印结果:
大概时间是1.5秒左右
并发式执行:
public class Test {
private static final long count = 10_0000_0000L;
public static void concurrency(){
long beg = System.currentTimeMillis();
Thread t1 = new Thread(){
@Override
public void run() {
int a = 0;
for (long i = 0; i < count ; i++) {
a++;
}
}
};
t1.start();
Thread t2 = new Thread(){
@Override
public void run() {
int b = 0;
for (long i = 0; i
打印结果:
大概时间是0.7秒左右
串行执行:1500 - 1700毫秒左右
并发执行 800 - 900毫秒左右
速度确实是提高了!!
是正好提高一倍嘛?
不是
不一定
线程调度,自身也是有开销的~~
一个线程执行了20亿次循环.
中间可能会调度若干次(调度时间会花一定的时间)
现在是两个线程各自执行10亿次循环.
中间也可能会调度若干次(也会花一定的时间)
这两组调度的时间具体是多少,完全不确定
Thread类具体的用法(所包含的一些属性和方法 )
Thread 的 name,存在的意义就是为了方便调试~~
如果线程多了,就容易弄混~
给线程起一个名字之后,调试的时候就可以很清楚的看到当前的线程谁是谁
public class TestDome {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
while (true) {
System.out.println("hello,thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
},"mythread");
t.start();
}
}
在代码里面我们给线程的构造方法中传入了一个名字,如实我们创建出来的线程就带有这个名字
写代码的时候一定要关注程序是不是方便调试
如何在IDEA中给变量/方法/类重命名??
shift + f6
重命名会把所有有关联的代码都自动进行修改
此处说的是线程的状态,和上节课的"进程状态"是类似的效果.
存在的意义都是辅助进行线程调度
优先级也就和上节课"进程的优先级"是类似的效果.
此处的状态和优先级,和内核PCB中的状态优先级并不完全一致
创建的一个线程,默认不是后台线程
此时,如果main方法结束了,线程还没结束,JVM进程不会结束
如果当前线程是后台线程
此时,如果main方法结束了,线程还没有结束,JVM进程就会直接结束,同时也就把这个后台线程也一起带走了
(是否是后台线程,影响了JVM进程是否能够退出)
内核中的PCB是不是销毁了(系统中线程是不是销毁了)
1
2
3
我们通过代码看一下Thread的这些属性和方法
public class TestDome1 {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
while (true){
//打印当前线程的名字
//Thread.currentThread()这个静态方法,获取到当前线程实例
//哪个线程调用这个方法,就能获取到当前线程实例
System.out.println(Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
},"myThread");
t.start();
//在这里也打印一下这个线程的属性
System.out.println("id: " + t.getId() );
System.out.println("name: " + t.getName());
System.out.println("state: " + t.getState());
System.out.println("priority: " + t.getPriority());
System.out.println("isDaemon" + t.isDaemon());
System.out.println("isInterrupted: "+t.isInterrupted());
System.out.println("isAlive " + t.isAlive());
}
我们先看一下线程没跑起来的信息:
state,这个状态是NEW,这个状态就表示Thread对象有了,但是PCB还没有创建
isAlive:false:当前的PCB是没有的
线程跑起来的信息:
isAlive:true:表示PCB已经有了
state:RUNNABLE
使用Java来操作线程
在Java中,使用Thread这个类的对象来表示一个操作系统中的线程
PCB是在操作系统内核中,描述线程的
Thread类是在咱们Java中描述线程的
//Thread是 Java 标准库中描述一个关于线程的类
//常用的方法就是自己定义一个类继承 Thread
//重写 Thread 中的 run 方法. run方法就是表示线程要执行的具体任务(代码).
class MyThread extends Thread{
@Override
public void run() {
System.out.println("hello,Thread");
}
}
public class Test {
public static void main(String[] args) {
Thread thread = new MyThread();
//stat 方法,就会在操作系统中真的创建一个线程出来,(内核中搞个PCB,加入到双链表中)
//这个新的线程,就会执行 run中所描述的代码
thread.start();
thread.run()
}
}
thread.strat()和thread.run()的区别(经典面试题)
换一种写法:
class MyThread1 extends Thread{
//1.
@Override
public void run() {
while(true){
System.out.println("hello,Thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
public class TestDome {
//2.
public static void main(String[] args) {
Thread t = new MyThread1();
t.start();
while (true){
System.out.println("hello,main");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
新线程MyThread1里面是一个死循环,会一直循环执行.main函数主线程里面也会一直循环执行.都是死循环,这两个代码能够同时执行吗
按照现在的说法是可以同时执行的
因为1是一个执行流
2也是一个执行流
他俩之间是并发的关系
运行程序观察结果:
此时可以看到这俩逻辑都在执行,在交替打印
通过刚才的代码我们就可以看到通过这样的一个线程就可以让这两个死循环能够按照并发的方式一起来去跑.而不是说单纯的执行完一个再去执行下一个
这是通过start创建线程来这么做的
如果把start改成run呢?
我们看一下:
class MyThread1 extends Thread{
@Override
public void run() {
while(true){
System.out.println("hello,Thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
public class TestDome {
public static void main(String[] args) {
Thread t = new MyThread1();
//t.start();
t.run();
while (true){
System.out.println("hello,main");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
如果改成run的话就是一个线程内部来完成两个循环了
执行到run循环里面之后就会打印"hello,Thread",因为是死循环所以下面的循环就不会执行
运行程序观察结果:
线程的创建还有很多方式:
1.就是上面我们举例的这种方式通过继承THread,重写 run.
2.实现Runnable接口,重写 run方法.
我们写一下第二种方式
标准库提供的一个接口
字面意思"可运行的"
这个接口主要用于描述"一个任务"
通过run方法来描述具体要执行的代码是啥~~
class MyThread2 implements Runnable{
@Override
public void run() {
while(true){
System.out.println("hello,Thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
public class TestDome2 {
public static void main(String[] args) {
//注意:Runnable并不能够独立去使用,要搭配Thread类来使用
Thread t = new Thread(new MyThread2());
t.start();
}
}
观察运行结果:
第三种方式:
继承Thread,重写 run,使用匿名内部类的方式
内部类:在一个类里面定义类
匿名内部类:一个没有类名的内部类
没有类名没关系,至少可以创建出一个实例来~
什么时候需要使用匿名内部类:只需要用这个实例,不需要用其他实例了
public class TestDemo3 {
public static void main(String[] args) {
//这个语法就是匿名内部类
//相当于是创建了一个匿名的类,这个类继承了 Thread.
//此处咱们 new 的实例,其实是 new 了这个新的子类的实例
Thread t = new Thread(){
@Override
public void run() {
while(true){
System.out.println("hello,thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
};
t.start();
}
}
这种写法,本质上和单独创建一个类,再继承 Thread 是没区别的
第三种写法和第一种写法本质上没有区别,只不过第三种写法写起来更简单一点~
我们把这种写法称为(语法糖)
这种写法习惯了之后可读性是并不低~~
比较悲伤的是,Java里面方法不能脱离类存在
所以才有匿名内部类和这种稍微复杂一点的写法
第四种写法:
实现Runnable,重写run,使用匿名内部类~
public class TestDome4 {
public static void main(String[] args) {
Thread t = new Thread(new Runnable(){
@Override
public void run() {
System.out.println("hello,Thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
}
}
第五种写法:适用lambda表达式来表示要执行的任务~
lambda:很多语言都有lambda,本质上是一个匿名函数
public class TestDome5 {
public static void main(String[] args) {
Thread t = new Thread(() ->{
while (true){
System.out.println("hello,Thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
t.start();
}
}
lambda表达式,是直接了当的指定这样的任务~~
以上这些创建线程的方式,本质都相同
都是借助Thread类,在内核中创建新的PCB,加入到内核的双向链表中......
只不过区别是,指定线程要执行的任务方式不一样.
此处的区别,其实都只是单纯的java语法层面的区别~
能否更明显的看到有新的线程出来?
在JDK中内置了一个jconsole工具~
就可以看到线程的信息~
(IDEA也能看到)
具体效率怎么提高的?能提高多少我们看下面代码:
我们先看这个数字:
我们在写一个比较大的字面值常量的时候,如果0太多了
就容易数不清.建议使用下划线来做出分割
我们可以试一下分别是并发的方式,串行的方式
比如现在有个变量a和b
循环的对于a自增10亿次
循环的对于b也自增10亿次
分别通过串行的方式和并发(多线程),执行~
串行执行:
public class Test { private static final long count = 10_0000_0000L; //串行的来针对 a 和 b 进行自增 //serial意为串行 public static void serial(){ //System.currentTimeMillis()获取到当前系统的毫秒级时间戳 long beg = System.currentTimeMillis(); int a = 0; for (long i = 0; i < count ; i++) { a++; } int b = 0; for (long i = 0; i打印结果:
大概时间是1.5秒左右
并发式执行:
public class Test { private static final long count = 10_0000_0000L; public static void concurrency(){ long beg = System.currentTimeMillis(); Thread t1 = new Thread(){ @Override public void run() { int a = 0; for (long i = 0; i < count ; i++) { a++; } } }; t1.start(); Thread t2 = new Thread(){ @Override public void run() { int b = 0; for (long i = 0; i打印结果:
大概时间是0.7秒左右
串行执行:1500 - 1700毫秒左右
并发执行 800 - 900毫秒左右
速度确实是提高了!!
是正好提高一倍嘛?
不是
不一定
线程调度,自身也是有开销的~~
一个线程执行了20亿次循环.
中间可能会调度若干次(调度时间会花一定的时间)
现在是两个线程各自执行10亿次循环.
中间也可能会调度若干次(也会花一定的时间)
这两组调度的时间具体是多少,完全不确定
Thread类具体的用法(所包含的一些属性和方法 )
Thread 的 name,存在的意义就是为了方便调试~~
如果线程多了,就容易弄混~
给线程起一个名字之后,调试的时候就可以很清楚的看到当前的线程谁是谁
public class TestDome {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
while (true) {
System.out.println("hello,thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
},"mythread");
t.start();
}
}
在代码里面我们给线程的构造方法中传入了一个名字,如实我们创建出来的线程就带有这个名字
写代码的时候一定要关注程序是不是方便调试
如何在IDEA中给变量/方法/类重命名??
shift + f6
重命名会把所有有关联的代码都自动进行修改
此处说的是线程的状态,和上节课的"进程状态"是类似的效果.
存在的意义都是辅助进行线程调度
优先级也就和上节课"进程的优先级"是类似的效果.
此处的状态和优先级,和内核PCB中的状态优先级并不完全一致
创建的一个线程,默认不是后台线程
此时,如果main方法结束了,线程还没结束,JVM进程不会结束
如果当前线程是后台线程
此时,如果main方法结束了,线程还没有结束,JVM进程就会直接结束,同时也就把这个后台线程也一起带走了
(是否是后台线程,影响了JVM进程是否能够退出)
内核中的PCB是不是销毁了(系统中线程是不是销毁了)
1
2
3
我们通过代码看一下Thread的这些属性和方法
public class TestDome1 {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
while (true){
//打印当前线程的名字
//Thread.currentThread()这个静态方法,获取到当前线程实例
//哪个线程调用这个方法,就能获取到当前线程实例
System.out.println(Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
},"myThread");
t.start();
//在这里也打印一下这个线程的属性
System.out.println("id: " + t.getId() );
System.out.println("name: " + t.getName());
System.out.println("state: " + t.getState());
System.out.println("priority: " + t.getPriority());
System.out.println("isDaemon" + t.isDaemon());
System.out.println("isInterrupted: "+t.isInterrupted());
System.out.println("isAlive " + t.isAlive());
}
我们先看一下线程没跑起来的信息:
state,这个状态是NEW,这个状态就表示Thread对象有了,但是PCB还没有创建
isAlive:false:当前的PCB是没有的
线程跑起来的信息:
isAlive:true:表示PCB已经有了
state:RUNNABLE
Thread 的 name,存在的意义就是为了方便调试~~
如果线程多了,就容易弄混~
给线程起一个名字之后,调试的时候就可以很清楚的看到当前的线程谁是谁
public class TestDome {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
while (true) {
System.out.println("hello,thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
},"mythread");
t.start();
}
}
在代码里面我们给线程的构造方法中传入了一个名字,如实我们创建出来的线程就带有这个名字
写代码的时候一定要关注程序是不是方便调试
如何在IDEA中给变量/方法/类重命名??
shift + f6
重命名会把所有有关联的代码都自动进行修改
此处说的是线程的状态,和上节课的"进程状态"是类似的效果.
存在的意义都是辅助进行线程调度
优先级也就和上节课"进程的优先级"是类似的效果.
此处的状态和优先级,和内核PCB中的状态优先级并不完全一致
创建的一个线程,默认不是后台线程
此时,如果main方法结束了,线程还没结束,JVM进程不会结束
如果当前线程是后台线程
此时,如果main方法结束了,线程还没有结束,JVM进程就会直接结束,同时也就把这个后台线程也一起带走了
(是否是后台线程,影响了JVM进程是否能够退出)
内核中的PCB是不是销毁了(系统中线程是不是销毁了)
1
2
3
我们通过代码看一下Thread的这些属性和方法
public class TestDome1 {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
while (true){
//打印当前线程的名字
//Thread.currentThread()这个静态方法,获取到当前线程实例
//哪个线程调用这个方法,就能获取到当前线程实例
System.out.println(Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
},"myThread");
t.start();
//在这里也打印一下这个线程的属性
System.out.println("id: " + t.getId() );
System.out.println("name: " + t.getName());
System.out.println("state: " + t.getState());
System.out.println("priority: " + t.getPriority());
System.out.println("isDaemon" + t.isDaemon());
System.out.println("isInterrupted: "+t.isInterrupted());
System.out.println("isAlive " + t.isAlive());
}
我们先看一下线程没跑起来的信息:
state,这个状态是NEW,这个状态就表示Thread对象有了,但是PCB还没有创建
isAlive:false:当前的PCB是没有的
线程跑起来的信息:
isAlive:true:表示PCB已经有了
state:RUNNABLE



