JavaEE--2.多线程
1.认识线程(Thread)
1.1概念
1)什么是线程
⼀个线程就是⼀个 "执行流". 每个线程之间都可以按照顺序执行自己的代码. 多个线程之间 "同时" 执行着多份代码.
2)为什么要有线程
首先, "并发编程" 成为 "刚需".
1. 单核 CPU 的发展遇到了瓶颈. 要想提⾼算⼒, 就需要多核 CPU. ⽽并发编程能更充分利⽤多核 CPU 资源.
2. 有些任务场景需要 "等待 IO", 为了让等待 IO 的时间能够去做⼀些其他的⼯作, 也需要⽤到并发编程
其次, 虽然多进程也能实现 并发编程, 但是线程比进程更轻量
创建线程比创建进程更快.
销毁线程比销毁进程更快.
调度线程比调度进程更快.
最后, 线程虽然比进程轻量, 但是⼈们还不满足, 于是又有了 "线程池"(ThreadPool) 和 "协程" (Coroutine)
多进程的问题就是太"重"
创建/销毁进程的开销比较大(时间,空间)
一旦需求常见,需要频繁地创建销毁进程,开销非常明显.
最典型的例子就是服务器的开发:针对每个发送请求的客户端都创建一个单独的进程,由这个进程负责给客户端进行服务
为了解决进程开销比较大的问题,发明了"线程"(Thread)
线程可以理解成更轻量的进程,也能实现并发编程,创建/销毁的开销比进程更低.
因此,多线程的编程就成了当下主流的并发编程方式.
所谓的进程,在系统中是以PCB(进程控制块)这样的结构体来描述的,通过链表的形式来组织的
对于系统中,线程同样也是通过PCB来描述的(Linux)
一个进程其实是一组PCB
一个线程是一个PCB
所以,其中存在"包含关系”，一个进程中，可以包含多个线程
此时每个线程都可以独立的到CPU上调度执行
线程是系统“调度执行”的基本单位
进程是系统“资源分配”的基本单位
解释:一个可执行程序，运行的时候（双击），操作系统就会创建进程，给这个程序分配各种系统资源（CPU,内存,硬盘,网络带宽......）,同时,也会在这个进程中,创建出一个或者多个线程,这些线程再去CPU上调度执行.
上个文章提到的"进程调度"相当于"线程调度",针对"只包含一个线程的进程来说"
如果有多个线程在一个进程中,每个线程,都会有自己的状态,优先级,上下文,记账信息,每个都会各自独立的在CPU上调度执行
进程要么包含一个线程,要么包含多个线程,不能没有线程
同一个进程的这些线程,共用着同一个系统资源
线程比进程更轻量,主要就在与创建线程省去了"分配资源"过程,销毁线程也省去了"释放资源"过程.
分配资源这个操作的开销大
一旦创建进程,同时也会创建第一个线程=>就会负责分配资源
一旦后续创建第二个第三个线程,就不必再重新分配资源了....
从微观角度看,多个核心,每个核心都可以执行一个线程,这些核心之间的执行过程是"同时执行的",这时称之为"并行"
一个核心,也可以按照"分时复用",来切换多个线程,从微观上来看.多个线程是"一个接一个"的执行的,由于调度速度足够快,宏观上看起来好像"同时执行",这时称之为"并发"
提升效率的关键是在于充分利用多核心进行"并行执行"
如果只是"微观并发",速度是没有提升的
真正能提升速度的是"并行"
线程有关的问题:
1.线程数目太多
如果线程数目太多,比如超出了CPU核心数目.此时就无法在微观上完成"并行"执行,势必会存在严重的"竞争".
2.进程资源"冲突"
当线程数目多了之后,此时就容易发生"冲突",由于多个线程,使用的是同一份资源(内存资源)
内存资源指的是代码中定义的变量/对象,如果多个线程同时对一个变量进行读写操作(尤其是写操作)容易发生冲突
一旦发生冲突,就可能使程序出现问题("线程安全问题"[重点内容,难点内容])
3.线程异常
当一个进程中有多个线程的时候,一旦某个线程抛出异常,这个时候,如果未能妥善处理,可能导致整个进程崩溃,其他线程就会随之崩溃
总结下(这也是高频的面试题)
进程线程的概念和区别
1.进程包含线程
一个进程里可以有一个线程,也可以有多个线程,不能没有线程
2.进程是系统资源分配的基本单位
线程是系统调度执行的基本单位
3.同一个进程里的线程之间,共用着同一份系统资源(内存,硬盘,网络带宽等...)
尤其是"内存资源",就是代码中定义的变量/对象...
编程中,多个线程,是可以共用同一份变量的
4.线程是当下实现并发编程的主流方式,通过多线程,就可以充分利用好多核CPU
但是不是线程数目越多越好,线程数目达到一定程度,把多个核心都充分利用了之后,此时继续增加线程无法再提高效率,甚至可能会影响效率(线程调度也是有开销的)
5.多个线程之间,可能会互相影响,线程安全问题,一个线程抛出异常,也可能会把其他线程也一起带走
6.多个进程之间,一般不会相互影响,一个进程崩溃了,不会影响到其他进程(这一点也称为"进程的隔离性")
3)进程和线程的区别
进程是包含线程的,每个进程至少有一个线程,即主线程.
进程和进程之间不共享内存空间,同一进程的线程之间共享同一个内存空间
进程是资源分配的基本单位,线程是系统调度的基本单位
一个进程挂了一般不会影响到其他进程,一个线程挂了可能会把同进程的其他线程一起带走(整个进程崩溃).
4)Java的线程和操作系统线程的关系
线程是操作系统中的概念,操作系统内核实现了线程这样的机制,并且对用户提供了一些API供用户使用(例如Linux的pthread库).
Java标准库中的Thread类可以视为对操作系统提供的API进行了进一步的抽象和封装.
Java(JVM)把这些系统API封装好了,咱们不需要关注系统原生API,只需要了解好Java提供的这一套API就行了
1.2第一个多线程程序
Thread标准库:
这个类就负责完成多线程相关的开发.
此处Thread类可以直接使用,不需要导入任何的包
(因为有的类比较特殊,默认已经导入了,比如String)
此处的继承不是主要目的,更主要的目的是为了重写run方法
调用start就会在进程内部创建出新的线程,新的线程就会执行刚才run里面的代码
上述代码没有run方法没有手动的去调用但是最终也是执行了像run这种用户手动定义,但是没有用户手动调用,最终这个方法被系统/库/框架进行调用了此时,这样的方法被称为"回调函数"(callback)回调函数是编程中一个非常重要的概念
回调函数是一个非常重要的概念!!
回调函数概念其实目前至少遇到过两次
1.C语言中的函数指针
函数指针主要有两个用途
a)作为回调函数
b)实现转移表--降低代码的复杂程度
2.Java数据结构中的优先级队列
优先级队列必须先定义好对象的"比较规则" Comparable Compareto
Comparator Compare
自己定义了这些比较规则,但是并没有调用,此时都是标准库本身内部的逻辑负责调用
这个代码运行起来,是一个进程,但是这个进程实际上是包含了两个线程!
调用main方法的线程称为"主线程"
一个进程至少得包含一个线程,至少这一个线程就是主线程
t.start() 这里又手动的创建了新的线程
主线程和新线程都并发/并行的在CPU上执行
Thread,sleep();是Thread的静态方法 类名.方法名
Java标准库提供的方法
C语言中也有类似的,Sleep() (Windows的系统函数)
多线程之间谁先去CPU上调度执行,这个过程是"不确定的"(不是数学意义上的随机)
而是这个调度顺序取决于操作系统,内核里"调度器"的实现
调度器里有一套规则,咱们作为应用程序开发没办法进行干预,也感受不到
只能将这个过程近似的视为"随机" "抢占式执行"
借助第三方工具更直观的来看这两个线程的情况
在jdk的bin目录中打开jconsole
可以看出当前java进程中线程的情况,左下角可以看出一个java进程中不只有两个线程,还有别的
main是主线程,调用main方法的
Thread-0是代码中自己创建的线程,它的命名规律是Thread-数字
在IDEA的调试器,也能看到类似的信息
就可以手动的切换都某个线程上,看你需要关注的一些信息
创建线程的写法
1)继承Thread,重写run
上面的写法就是继承Thread类
1.继承 Thread 来创建⼀个线程类.
class MyThread extends Thread {@Overridepublic void run() {System.out.println("这⾥是线程运⾏的代码");}
}2.创建 MyThread 类的实例
MyThread t = new MyThread();3.调用 start 方法启动线程
t.start();全部代码:
2)实现Runnable接口,重写run
1.实现 Runnable 接口
class MyRunnable implements Runnable {@Overridepublic void run() {System.out.println("这⾥是线程运⾏的代码");}
}2.创建 Thread 类实例, 调⽤ Thread 的构造⽅法时将 Runnable 对象作为 target 参数.
Thread t = new Thread(new MyRunnable());3.调用 start 方法
t.start();全部代码:
Runnable就是用来描述"要执行的任务" 是什么
有人认为Runnable这种做法更有利于"解耦合",这只是一个任务,并不是和"线程"这样的概念强相关
后续执行这个任务的载体可以是线程也可以是别的
别的在这里比如后续会介绍的线程池来执行任务
再比如可以通过"虚拟线程"(协程)来执行~~
线程是轻量级进程,因为进程太重量了,随着对于性能要求进一步提高,开始嫌弃线程也太重量了
于是引入了"协程".(轻量级线程,纤程)
这个协程的概念在后续的java版本中就被引入了,起的名叫做"虚拟线程"
3)内部匿名类
内部匿名类没有类目
Runnable子类对象
Thread子类对象
1.定义匿名内部类,这个类是Thread的子类
2.类的内部重写的父类run方法
3.创建了一个子类的实例,并且把实例的引用赋值给了t
匿名内部类就是一次性使用的类,用完就丢
4.lambda表达式创建Runnable子类
Thread thread=new Thread(() -> {while(true){System.out.println("这是线程输出的");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}});thread.start();while(true){System.out.println("这是main运行的代码");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}这也是推荐的写法
后续多以lambda表达式来创建多线程
2.1Thread的常见构造方法
| 方法 | 说明 |
| Thread() | 创建线程对象 |
| Tread(Runnable target) | 使用Runnable对象创建线程对象 |
| Thread(String name) | 创建线程对象,并命名 |
| Tread(Runnable target,String name) | 使用Runnable对象创建线程对象,并命名 |
| [了解]Thread(ThreadGoup goup,Runnable target) | 线程可以被用来分组管理,方便统一的设置线程的一些属性 |
注:给线程起名字不会影响到线程的执行效果,但是有一个合适的名字有利于调试的结果
不起名字默认就是Thread-0,Thread-1...
现在很少会使用线程组,线程的相关属性用的也不多,现在更多的是会使用线程池
2.2Thread的几个常见的属性
| 属性 | 获取方法 |
| ID | getId() |
| 名称 | getName() |
| 状态 | getState() |
| 优先级 | getPriority() |
| 是否后台线程 | isDaemon() |
| 是否存活 | isAlive() |
| 是否被中断 | isInterrupted() |
1.ID是线程的唯一标识,不同的线程不会重复
JVM自动分配的,Thread对象的身份标识
2.名称是各种调试工具用到的
3.状态表示线程当前所处的一个情况,下面我们会具体说明
就绪/阻塞状态 就绪状态的名字为RUNNABLE
通常情况下,一个Thread对象,就是对应到系统内部的一个线程(PCB),但是也可能会存在一个情况,Thread对象存在,但是系统内部的线程已经没了/还没有创建
4.优先级高的线程理论上来说更容易被调度到
设计不同的优先级影响系统的调度,这里的影响是基于"统计"规则的影响,直接肉眼观察河南观察到效果
5.关于后台线程,需要记住一点:JVM会在一个进程的所有非后台线程结束后才会结束运行
后台线程:如果这个线程执行的过程中不能阻止进程结束(虽然线程在执行,但是进程结束了,这个线程也会被随之带走),这样的线程就是"后台线程"
前台线程:如果某个线程在执行的过程中,能够阻止进程的结束,这个线程就是"前台进程 "
6.是否存活,即简单的理解run的方法是否结束了
true为存在,false为无了
由于主线程和thread线程并发执行,主线程执行上述4个操作,执行了一部分的时候thread线程就执行打印了
RUNNABLE正在运行,实际上Java没有RUNNABLE这个线程状态,把正在CPU上运行和随时调度到CPU上运行的都统称为RUNNABLE
后台线程:
1)进程要结束(前台线程要结束),无力阻止
2)后台线程先结束也不影响进程的结束(其他前台进程的结束)
前台进程:
1)前台线程结束,此时进程就结束,后台线程也就随之结束
2)前台线程不结束,后台线程结束了不影响
一个进程中,前台线程可以有很多个(创建的线程默认就是前台的),必须所有的前台线程都结束,进程才能结束
代码中,创建的new Thread对象生命周期和内核中的实际的线程是不一定一样的
可能会出现Thread对象仍然存在,但是内核中的线程不存在的情况但是不会出现(Thread对象不存在,线程还在的情况)
1.调用start之前,内核中还没创建线程
2.线程的run执行完毕,内核的线程就没了,但是Thread对象仍然存在
2.3启动一个线程
调用start方法,才真正的在操作系统的底层创建出一个线程.
经典问题:start和run之间的区别
start:调用系统函数,真正的在操作系统内核中创建线程(创建PCB,加入到链表中),此处的start会根据不同的系统,分别调出不同的api(windows,linux,mac...),创建好新的线程之后再单独执行run
run:描述了线程要执行的的任务,也可以成为"线程的入口"
start的执行速度一般是比较快的(创建线程 比较轻量)
一旦start执行完毕,新线程就会开始执行,调用start的线程也会继续执行main
两个线程分别个做个的
调用start不一定非得是main线程调用的,任何线程都可以创建其他线程
如图:这里就是由thread调用了thread1线程
如果系统资源充裕,就可以任意的创建线程,(当然,线程不是越多越好);
一个Thread对象只能调用一次start,如果多次调用start就会出现问题(一个Thread对象只能对应系统中的一个线程)
IllegalThreadStateException 报错
由于Java中希望一个Thread对象能够对应到一个系统中的线程,因此就会 start中根据线程状态做出判定:如果Thread对象是没有start,此时的状态是一个NEW状态,接下来可以顺利调用start,如果已经调用过start,就会进入其他状态,只要不是NEW状态,接下来执行start都会抛出异常
2.4程序的中断(程序的终止)
目前常见的有以下的两种方法:
1.通过共享的标记来进行沟通
2.调用interrupt()方法来停止
例如:A,B两个线程,B正在运行,A想让B结束,核心在于A让B的run方法直接完毕,此时B就自然结束了,而不是说B的run执行一般,A直接把B强制结束了
用共享标记结束,例如:
private static boolean isQuit=false;public static void main(String[] args) throws InterruptedException {Thread thread=new Thread(()->{while(!isQuit){System.out.println("hello thread");try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}}});thread.start();Thread.sleep(3000);System.out.println("main方法开始中断程序");isQuit=true;}用isQuit来作为标志位
如果将isQuit放在main方法里面,作为局部变量,代码会报错
变量捕捉,是lambda表达式/匿名内部类的一个语法规则
isQuit和lambda定义在一个作用域中,此时lambda是可以访问到lambda外部(和lambda同一个作用域的变量),Java的变量捕捉有特殊要求,要求捕捉的变量得是final/事实final
写成成员变量之后就可以了是因为此时走的语法是"内部类访问外部类的成员"
lambda表达式本质上是一个"函数式接口"产生的"匿名内部类"
2.调用interrupt来终止
1)interrupt方法能够设置标志位,也能唤醒sleep等阻塞的方法(会抛出异常)
2)sleep被唤醒后,会清空标志位
如图可以看出,标志位被sleep清空,并没有中断此线程
线程A和线程B,A希望B线程终止
1)如果B线程想无视A线程,就直接catch中啥也不做
B线程仍然会继续执行
sleep清除标志位,就可以使B能做出这种选择,如果sleep不清楚标志位,B势必会结束,无法写出继续让线程继续的代码
2)如果B线程想立即结束就直接在catch中写上return或者break
此时B线程就会立即结束
3)如果B想稍后再结束,就可以在catch中写上一些其他的逻辑(比如释放资源,清除硬一些数据,提交一些结果....收尾工作)
这些逻辑完成之后再进行return/break;
这些给了程序员更多的操作空间
2.5等待一个线程-join()
操作系统针对多个线程的执行是一个"随机调度,抢占式执行"的过程
线程等待就是在确定两个线程的结束顺序
无法确定两个线程调度执行顺序,但是可以控制谁先结束,谁后结束
让后结束的线程等待先结束的线程即可,此时后结束的线程会进入阻塞,一直到先结束的线程真的结束了,阻塞才结束
| 方法 | 说明 |
| public void join() | 等待线程结束 |
| public void join(long millis) | 等待线程结束,醉倒等millis毫秒 |
| public boid join(long millis,int nanos) 一般不用,后面是精确到纳秒 | 同理,但可以更高精度 |
因为计算机很难做到精确计时,一般能精准到ms就不错了
和操作系统相关像windows,linux系统,线程调度开销比较大,操作系统中还有一类系统"实时操作系统"就能把调度开销尽可能降低,开销小于一定的误差要求,从而可以做到更精准
Thread thread1=new Thread(()->{for(int i=0;i<3;i++){System.out.println("Hello thread1");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}});Thread thread2=new Thread(()->{for(int i=0;i<4;i++){System.out.println("Hello thread2");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}});System.out.println("main开始");thread1.start();thread2.start();try {thread1.join();} catch (InterruptedException e) {e.printStackTrace();}try {thread2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("main结束");
此代码为例,就是main线程等待thread1和thread2结束后才往下运行
当然不一定是main去等待,thread1也可以去等待thread2结束后再继续
代码如下
public static void main(String[] args) {Thread thread1=new Thread(()->{for(int i=0;i<3;i++){System.out.println("Hello thread1");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}});Thread thread2=new Thread(()->{try {thread1.join();} catch (InterruptedException e) {e.printStackTrace();}for(int i=0;i<4;i++){System.out.println("Hello thread2");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}});System.out.println("main开始");thread2.start();thread1.start();try {thread2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("main结束");}这里就是thread2中等待thread1
2.6获取当前线程的引用
| 方法 | 说明 |
| public static Thread currentThread(); | 返回当前线程对象的引用 |
2.7休眠当前线程
线程执行sleep,就会使得这个线程不参与CPU调度,从而把资源让出来给别人使用
"放权"
| 方法 | 说明 |
| public static void sleep(long millis) throws InterruptedException | 休眠当前线程 |
| public static void sleep(long millis,int nanos) throws InterruptedException | 可以更高精度精确到纳秒 |
3.线程的状态
进程的状态:
就绪:正在CPU上执行,或者随时可以去CPU上执行
阻塞:暂时不能去参与CPU执行
Java的线程对于状态做了更详细的区分,不仅仅是就绪和阻塞了
六种状态
1.NEW 这种Thread对象虽然有了,但是内核的线程还没有(还没有调用start)
public static void main(String[] args) {//匿名内部类的lambda表达式创建Runnable子类对象,备份下Thread thread=new Thread(() -> {for (int i=0;i<3;i++){System.out.println("Hello Thread");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}});System.out.println(thread.getState());thread.start();
}
2.TERMINATED 当前Thread对象虽然还在,但是内核的线程已经销毁(线程已经结束了)
public static void main(String[] args) {//匿名内部类的lambda表达式创建Runnable子类对象,备份下Thread thread=new Thread(() -> {for (int i=0;i<3;i++){System.out.println("Hello Thread");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}});thread.start();try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(thread.getState());}
3.RUNNABLE 就绪状态.正在CPU上运行+随时可以去CPU上去运行
public static void main(String[] args) {//匿名内部类的lambda表达式创建Runnable子类对象,备份下Thread thread=new Thread(() -> {while(true){}});thread.start();System.out.println(thread.getState());}
4.BKLOCKED 因为锁竞争引起的阻塞
public static void main(String[] args) throws InterruptedException {//匿名内部类的lambda表达式创建Runnable子类对象,备份下Thread thread1=new Thread(() -> {synchronized (Locker) {for (int i = 0; i < 50000; i++) {count++;}}});Thread thread2=new Thread(()->{synchronized(Locker){for(int i=0;i<50000;i++) {System.out.println(thread1.getState());count++;}}});thread1.start();thread2.start();thread1.join();thread2.join();System.out.println(count);}
5.TIMED_WAITING 有超时时间的阻塞等待,比如sleep或者join带参数版本
public static void main(String[] args) {//匿名内部类的lambda表达式创建Runnable子类对象,备份下Thread thread=new Thread(() -> {while(true){System.out.println("hello thread");try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}}});thread.start();try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(thread.getState());}
6.WAITING 没有超时时间的阻塞等待,join/wait
public static void main(String[] args) throws InterruptedException {//匿名内部类的lambda表达式创建Runnable子类对象,备份下Thread thread=new Thread(() -> {while(true){}});Thread thread2=new Thread(()->{try {thread.start();thread.join();} catch (InterruptedException e) {e.printStackTrace();}});thread2.start();Thread.sleep(3000);System.out.println(thread2.getState());}
学习线程状态主要就是为了调试,比如遇到某个代码功能没有执行就可以观察对应线程的状态,看看是否是因为一些原因阻塞了.