线程基础 + Java线程）"/>
JUC并发编程1（线程基础 + Java线程）
JUC并发编程1（线程基础 + Java线程）
笔记内容来源于黑马程序员教学视频
环境准备
- 导入依赖
<dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.24</version>
</dependency><dependency><groupId>ch.qos.logback</groupId><artifactId>logback-classic</artifactId><version>1.2.11</version>
</dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13.2</version>
</dependency><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-api</artifactId><version>1.7.30</version>
</dependency>
- logback.xml 配置如下：
<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true"><appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender"><encoder><pattern>%date{HH:mm:ss} [%t] %logger - %m%n</pattern></encoder></appender><logger name="c" level="debug" additivity="false"><appender-ref ref="STDOUT"/></logger><root level="ERROR"><appender-ref ref="STDOUT"/></root>
</configuration>
一、线程基础
①：Java多线程相关概念
1、进程
是程序的⼀次执⾏，是系统进⾏资源分配和调度的独⽴单位，每⼀个进程都有它⾃⼰的内存空间和系统资源
进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。程序是指令、数据及其组织形式的描述，进程是程序的实体。
进程具有的特征：
- 动态性：进程是程序的一次执行过程，是临时的，有生命期的，是动态产生，动态消亡的
- 并发性：任何进程都可以同其他进行一起并发执行
- 独立性：进程是系统进行资源分配和调度的一个独立单位
- 结构性：进程由程序，数据和进程控制块三部分组成
我们经常使用windows系统，经常会看见.exe后缀的文件，双击这个.exe文件的时候，这个文件中的指令就会被系统加载，那么我们就能得到一个关于这个.exe程序的进程。进程是 “活” 的，或者说是正在被执行的。
2、线程
在同⼀个进程内⼜可以执⾏多个任务，⽽这每⼀个任务我们就可以看做是⼀个线程 ⼀个进程会有1个或多个线程的
线程是轻量级的进程，是程序执行的最小单元，使用多线程而不是多进程去进行并发程序的设计，是因为线程间的切换和调度的成本远远小于进程。
3、进程与线程的一个简单解释
进程（process）和线程（thread）是操作系统的基本概念，但是它们比较抽象，不容易掌握。
1.计算机的核心是CPU，它承担了所有的计算任务。它就像一座工厂，时刻在运行。
2.假定工厂的电力有限，一次只能供给一个车间使用。也就是说，一个车间开工的时候，其他车间都必须停工。背后的含义就是，单个CPU一次只能运行一个任务。
3.进程就好比工厂的车间，它代表CPU所能处理的单个任务。任一时刻，CPU总是运行一个进程，其他进程处于非运行状态。
4.一个车间里，可以有很多工人。他们协同完成一个任务。
5.线程就好比车间里的工人。一个进程可以包括多个线程。
6.车间的空间是工人们共享的，比如许多房间是每个工人都可以进出的。这象征一个进程的内存空间是共享的，每个线程都可以使用这些共享内存。
7.可是，每间房间的大小不同，有些房间最多只能容纳一个人，比如厕所。里面有人的时候，其他人就不能进去了。这代表一个线程使用某些共享内存时，其他线程必须等它结束，才能使用这一块内存。
8.一个防止他人进入的简单方法，就是门口加一把锁。先到的人锁上门，后到的人看到上锁，就在门口排队，等锁打开再进去。这就叫”互斥锁”（Mutual exclusion，缩写 Mutex），防止多个线程同时读写某一块内存区域。
9.还有些房间，可以同时容纳n个人，比如厨房。也就是说，如果人数大于n，多出来的人只能在外面等着。这好比某些内存区域，只能供给固定数目的线程使用。
10.这时的解决方法，就是在门口挂n把钥匙。进去的人就取一把钥匙，出来时再把钥匙挂回原处。后到的人发现钥匙架空了，就知道必须在门口排队等着了。这种做法叫做”信号量”（Semaphore），用来保证多个线程不会互相冲突。
11.操作系统的设计，因此可以归结为三点： （1）以多进程形式，允许多个任务同时运行； （2）以多线程形式，允许单个任务分成不同的部分运行； （3）提供协调机制，一方面防止进程之间和线程之间产生冲突，另一方面允许进程之间和线程之间共享资源。
4、 并发与并行
单核cpu下，线程实际还是串行执行的。操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows 下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 cpu 在线程间（时间片很短）的切换非常快，人类感觉是同时运行的 。总结为一句话就是： 微观串行，宏观并行 。
一般会将这种线程轮流使用 CPU 的做法称为并发， concurrent
| CPU | 时间片 1 | 时间片 2 | 时间片 3 | 时间片 4 |
|---|---|---|---|---|
| core | 线程 1 | 线程 2 | 线程 3 | 线程 4 |
多核 cpu下，每个 核（core） 都可以调度运行线程，这时候线程可以是并行的。
| CPU | 时间片 1 | 时间片 2 | 时间片 3 | 时间片 4 |
|---|---|---|---|---|
| core1 | 线程 1 | 线程 2 | 线程 3 | 线程 4 |
| core2 | 线程 4 | 线程 4 | 线程 2 | 线程 2 |
引用 Rob Pike 的一段描述：
并发（concurrent）是同一时间应对（dealing with）多件事情的能力 。
并行（parallel）是同一时间动手做（doing）多件事情的能力。
5、管程
Monitor(监视器)，也就是我们平时所说的锁
// Monitor其实是一种同步机制，他的义务是保证（同一时间）只有一个线程可以访问被保护的数据和代码。
// JVM中同步是基于进入和退出监视器对象(Monitor,管程对象)来实现的，每个对象实例都会有一个Monitor对象，
Object o = new Object();
new Thread(() -> {synchronized (o){}
},"t1").start();
// Monitor对象会和Java对象一同创建并销毁，它底层是由C++语言来实现的。
6、线程状态？
// Thread.State
public enum State {NEW,(新建)RUNNABLE,（准备就绪）BLOCKED,（阻塞）WAITING,（不见不散）TIMED_WAITING,（过时不候）TERMINATED;(终结)
}
线程几个状态的介绍：
- New：表示刚刚创建的线程，这种线程还没有开始执行
- RUNNABLE：运行状态，线程的start()方法调用后，线程会处于这种状态
- BLOCKED：阻塞状态。当线程在执行的过程中遇到了synchronized同步块，但这个同步块被其他线程已获取还未释放时，当前线程将进入阻塞状态，会暂停执行，直到获取到锁。当线程获取到锁之后，又会进入到运行状态（RUNNABLE）
- WAITING：等待状态。和TIME_WAITING都表示等待状态，区别是WAITING会进入一个无时间限制的等，而TIME_WAITING会进入一个有限的时间等待，那么等待的线程究竟在等什么呢？一般来说，WAITING的线程正式在等待一些特殊的事件，比如，通过wait()方法等待的线程在等待notify()方法，而通过join()方法等待的线程则会等待目标线程的终止。一旦等到期望的事件，线程就会再次进入RUNNABLE运行状态。
- TERMINATED：表示结束状态，线程执行完毕之后进入结束状态。
注意：从NEW状态出发后，线程不能在回到NEW状态，同理，处理TERMINATED状态的线程也不能在回到RUNNABLE状态
7、wait/sleep的区别？
功能都是当前线程暂停，有什么区别？
wait放开手去睡，放开手里的锁
sleep握紧手去睡，醒了手里还有锁
②：线程的基本操作
1、新建线程
新建线程很简单。只需要使用new关键字创建一个线程对象，然后调用它的start()启动线程即可。
Thread thread1 = new Thread1();
t1.start();
那么线程start()之后，会干什么呢？线程有个run()方法，start()会创建一个新的线程并让这个线程执行run()方法。
这里需要注意，下面代码也能通过编译，也能正常执行。但是，却不能新建一个线程，而是在当前线程中调用run()方法，将run方法只是作为一个普通的方法调用。
Thread thread = new Thread1();
thread1.run();
所以，希望大家注意，调用start方法和直接调用run方法的区别。
start方法是启动一个线程，run方法只会在垫钱线程中串行的执行run方法中的代码。
默认情况下， 线程的run方法什么都没有，启动一个线程之后马上就结束了，所以如果你需要线程做点什么，需要把您的代码写到run方法中，所以必须重写run方法。
Thread thread1 = new Thread() { @Override public void run() { System.out.println("hello,我是一个线程!"); } };thread1.start();
上面是使用匿名内部类实现的，重写了Thread的run方法，并且打印了一条信息。我们可以通过继承Thread类，然后重写run方法，来自定义一个线程。 但考虑java是单继承的，从扩展性上来说，我们实现一个接口来自定义一个线程更好一些，java中刚好提供了Runnable接口来自定义一个线程。
@FunctionalInterfacepublic interface Runnable { public abstract void run();}
Thread类有一个非常重要的构造方法：
public Thread(Runnable target)
我们在看一下Thread的run方法：
public void run() { if (target != null) { target.run(); } }
当我们启动线程的start方法之后，线程会执行run方法，run方法中会调用Thread构造方法传入的target的run方法。
实现Runnable接口是比较常见的做法，也是推荐的做法。
2、终止线程
一般来说线程执行完毕就会结束，无需手动关闭。但是如果我们想关闭一个正在运行的线程，有什么方法呢？可以看一下Thread类中提供了一个stop()方法，调用这个方法，就可以立即将一个线程终止，非常方便。
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.TimeUnit;
@Slf4j
public class Demo01 {public static void main(String[] args) throws InterruptedException {Thread thread1 = new Thread() {@Overridepublic void run() {log.info("start");boolean flag = true;while (flag) {;}log.info("end");}};thread1.setName("thread1");thread1.start();//当前线程休眠1秒TimeUnit.SECONDS.sleep(1);//关闭线程thread1thread1.stop();//输出线程thread1的状态log.info("{}", thread1.getState());//当前线程休眠1秒TimeUnit.SECONDS.sleep(1);//输出线程thread1的状态log.info("{}", thread1.getState());}
}
运行代码，输出：
18:02:15.312 [thread1] INFO com.itsoku.chat01.Demo01 - start
18:02:16.311 [main] INFO com.itsoku.chat01.Demo01 - RUNNABLE
18:02:17.313 [main] INFO com.itsoku.chat01.Demo01 - TERMINATED
代码中有个死循环，调用stop方法之后，线程thread1的状态变为TERMINATED（结束状态），线程停止了。
我们使用idea或者eclipse的时候，会发现这个方法是一个废弃的方法，也就是说，在将来，jdk可能就会移除该方法。
stop方法为何会被废弃而不推荐使用？stop方法过于暴力，强制把正在执行的方法停止了。
大家是否遇到过这样的场景：电力系统需要维修，此时咱们正在写代码，维修人员直接将电源关闭了，代码还没保存的，是不是很崩溃，这种方式就像直接调用线程的stop方法类似。线程正在运行过程中，被强制结束了，可能会导致一些意想不到的后果。可以给大家发送一个通知，告诉大家保存一下手头的工作，将电脑关闭。
3、线程中断
在java中，线程中断是一种重要的线程写作机制，从表面上理解，中断就是让目标线程停止执行的意思，实际上并非完全如此。在上面中，我们已经详细讨论了stop方法停止线程的坏处，jdk中提供了更好的中断线程的方法。严格的说，线程中断并不会使线程立即退出，而是给线程发送一个通知，告知目标线程，有人希望你退出了！至于目标线程接收到通知之后如何处理，则完全由目标线程自己决定，这点很重要，如果中断后，线程立即无条件退出，我们又会到stop方法的老问题。
Thread提供了3个与线程中断有关的方法，这3个方法容易混淆，大家注意下：
public void interrupt() //中断线程
public boolean isInterrupted() //判断线程是否被中断
public static boolean interrupted() //判断线程是否被中断，并清除当前中断状态
interrupt() 方法是一个实例方法，它通知目标线程中断，也就是设置中断标志位为true，中断标志位表示当前线程已经被中断了。isInterrupted() 方法也是一个实例方法，它判断当前线程是否被中断（通过检查中断标志位）。最后一个方法interrupted() 是一个静态方法，返回boolean类型，也是用来判断当前线程是否被中断，但是同时会清除当前线程的中断标志位的状态。
while (true) {if (this.isInterrupted()) {System.out.println("我要退出了!");break;}}}
};
thread1.setName("thread1");
thread1.start();
TimeUnit.SECONDS.sleep(1);
thread1.interrupt();
上面代码中有个死循环，interrupt()方法被调用之后，线程的中断标志将被置为true，循环体中通过检查线程的中断标志是否为ture（this.isInterrupted()）来判断线程是否需要退出了。
再看一种中断的方法：
static volatile boolean isStop = false;
public static void main(String[] args) throws InterruptedException {Thread thread1 = new Thread() {@Overridepublic void run() {while (true) {if (isStop) {System.out.println("我要退出了!");break;}}}};thread1.setName("thread1");thread1.start();TimeUnit.SECONDS.sleep(1);isStop = true;
}
代码中通过一个变量isStop来控制线程是否停止。
通过变量控制和线程自带的interrupt方法来中断线程有什么区别呢？
如果一个线程调用了sleep方法，一直处于休眠状态，通过变量控制，还可以中断线程么？大家可以思考一下。
此时只能使用线程提供的interrupt方法来中断线程了。
public static void main(String[] args) throws InterruptedException {Thread thread1 = new Thread() {@Overridepublic void run() {while (true) {//休眠100秒try {TimeUnit.SECONDS.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("我要退出了!");break;}}};thread1.setName("thread1");thread1.start();TimeUnit.SECONDS.sleep(1);thread1.interrupt();
}
调用interrupt()方法之后，线程的sleep方法将会抛出InterruptedException异常。
Thread thread1 = new Thread() {@Overridepublic void run() {while (true) {//休眠100秒try {TimeUnit.SECONDS.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}if (this.isInterrupted()) {System.out.println("我要退出了!");break;}}}
};
运行上面的代码，发现程序无法终止。为什么？
代码需要改为：
Thread thread1 = new Thread() {@Overridepublic void run() {while (true) {//休眠100秒try {TimeUnit.SECONDS.sleep(100);} catch (InterruptedException e) {this.interrupt();e.printStackTrace();}if (this.isInterrupted()) {System.out.println("我要退出了!");break;}}}
};
上面代码可以终止。
注意：sleep方法由于中断而抛出异常之后，线程的中断标志会被清除（置为false），所以在异常中需要执行this.interrupt()方法，将中断标志位置为true
4、等待（wait）和通知（notify）
为了支持多线程之间的协作，JDK提供了两个非常重要的方法：等待wait()方法和通知notify()方法。这2个方法并不是在Thread类中的，而是在Object类中定义的。这意味着所有的对象都可以调用者两个方法。
public final void wait() throws InterruptedException;
public final native void notify();
当在一个对象实例上调用wait()方法后，当前线程就会在这个对象上等待。这是什么意思？比如在线程A中，调用了obj.wait()方法，那么线程A就会停止继续执行，转为等待状态。等待到什么时候结束呢？线程A会一直等到其他线程调用obj.notify()方法为止，这时，obj对象成为了多个线程之间的有效通信手段。
那么wait()方法和notify()方法是如何工作的呢？如图2.5展示了两者的工作过程。如果一个线程调用了object.wait()方法，那么它就会进出object对象的等待队列。这个队列中，可能会有多个线程，因为系统可能运行多个线程同时等待某一个对象。当object.notify()方法被调用时，它就会从这个队列中随机选择一个线程，并将其唤醒。这里希望大家注意一下，这个选择是不公平的，并不是先等待线程就会优先被选择，这个选择完全是随机的。
除notify()方法外，Object独享还有一个nofiyAll()方法，它和notify()方法的功能类似，不同的是，它会唤醒在这个等待队列中所有等待的线程，而不是随机选择一个。
这里强调一点，Object.wait()方法并不能随便调用。它必须包含在对应的synchronize语句汇总，无论是wait()方法或者notify()方法都需要首先获取目标独享的一个监视器。图2.6显示了wait()方法和nofiy()方法的工作流程细节。其中T1和T2表示两个线程。T1在正确执行wait()方法钱，必须获得object对象的监视器。而wait()方法在执行后，会释放这个监视器。这样做的目的是使其他等待在object对象上的线程不至于因为T1的休眠而全部无法正常执行。
线程T2在notify()方法调用前，也必须获得object对象的监视器。所幸，此时T1已经释放了这个监视器，因此，T2可以顺利获得object对象的监视器。接着，T2执行了notify()方法尝试唤醒一个等待线程，这里假设唤醒了T1。T1在被唤醒后，要做的第一件事并不是执行后续代码，而是要尝试重新获得object对象的监视器，而这个监视器也正是T1在wait()方法执行前所持有的那个。如果暂时无法获得，则T1还必须等待这个监视器。当监视器顺利获得后，T1才可以在真正意义上继续执行。
给大家上个例子：
public class Demo06 {static Object object = new Object();public static class T1 extends Thread {@Overridepublic void run() {synchronized (object) {System.out.println(System.currentTimeMillis() + ":T1 start!");try {System.out.println(System.currentTimeMillis() + ":T1 wait for object");object.wait();} catch (InterruptedException e) {e.printStackTrace();}System.out.println(System.currentTimeMillis() + ":T1 end!");}}}public static class T2 extends Thread {@Overridepublic void run() {synchronized (object) {System.out.println(System.currentTimeMillis() + ":T2 start，notify one thread! ");object.notify();System.out.println(System.currentTimeMillis() + ":T2 end!");try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}}}public static void main(String[] args) throws InterruptedException {new T1().start();new T2().start();}
}
运行结果：
1562934497212:T1 start!
1562934497212:T1 wait for object
1562934497212:T2 start，notify one thread!
1562934497212:T2 end!
1562934499213:T1 end!
注意下打印结果，T2调用notify方法之后，T1并不能立即继续执行，而是要等待T2释放objec投递锁之后，T1重新成功获取锁后，才能继续执行。因此最后2行日志相差了2秒（因为T2调用notify方法后休眠了2秒）。
注意：Object.wait()方法和Thread.sleep()方法都可以让现场等待若干时间。除wait()方法可以被唤醒外，另外一个主要的区别就是wait()方法会释放目标对象的锁，而Thread.sleep()方法不会释放锁。
再给大家讲解一下wait()，notify()，notifyAll()，加深一下理解：
可以这么理解，obj对象上有2个队列，如图1，q1：等待队列，q2：准备获取锁的队列；两个队列都为空。
obj.wait()过程：
synchronize(obj){obj.wait();
}
假如有3个线程，t1、t2、t3同时执行上面代码，t1、t2、t3会进入q2队列，如图2，进入q2的队列的这些线程才有资格去争抢obj的锁，假设t1争抢到了，那么t2、t3机型在q2中等待着获取锁，t1进入代码块执行wait()方法，此时t1会进入q1队列，然后系统会通知q2队列中的t2、t3去争抢obj的锁，抢到之后过程如t1的过程。最后t1、t2、t3都进入了q1队列，如图3。
上面过程之后，又来了线程t4执行了notify()方法，如下：**
synchronize(obj){obj.notify();
}
t4会获取到obj的锁，然后执行notify()方法，系统会从q1队列中随机取一个线程，将其加入到q2队列，假如t2运气比较好，被随机到了，然后t2进入了q2队列，如图4，进入q2的队列的锁才有资格争抢obj的锁，t4线程执行完毕之后，会释放obj的锁，此时队列q2中的t2会获取到obj的锁，然后继续执行，执行完毕之后，q1中包含t1、t3，q2队列为空，如图5
接着又来了个t5队列，执行了notifyAll()方法，如下：
synchronize(obj){obj.notifyAll();
}
2.调用obj.wait()方法，当前线程会加入队列queue1，然后会释放obj对象的锁
t5会获取到obj的锁，然后执行notifyAll()方法，系统会将队列q1中的线程都移到q2中，如图6，t5线程执行完毕之后，会释放obj的锁，此时队列q2中的t1、t3会争抢obj的锁，争抢到的继续执行，未增强到的带锁释放之后，系统会通知q2中的线程继续争抢索，然后继续执行，最后两个队列中都为空了。
5、挂起（suspend）和继续执行（resume）线程
Thread类中还有2个方法，即线程挂起(suspend) 和继续执行(resume) ，这2个操作是一对相反的操作，被挂起的线程，必须要等到resume()方法操作后，才能继续执行。系统中已经标注着2个方法过时了，不推荐使用。
系统不推荐使用suspend()方法去挂起线程是因为suspend()方法导致线程暂停的同时，并不会释放任何锁资源。此时，其他任何线程想要访问被它占用的锁时，都会被牵连，导致无法正常运行（如图2.7所示）。直到在对应的线程上进行了resume()方法操作，被挂起的线程才能继续，从而其他所有阻塞在相关锁上的线程也可以继续执行。但是，如果resume()方法操作意外地在suspend()方法前就被执行了，那么被挂起的线程可能很难有机会被继续执行了。并且，更严重的是：它所占用的锁不会被释放，因此可能会导致整个系统工作不正常。而且，对于被挂起的线程，从它线程的状态上看，居然还是Runnable状态，这也会影响我们队系统当前状态的判断。
上个例子：
public class Demo07 {static Object object = new Object();public static class T1 extends Thread {public T1(String name) {super(name);}@Overridepublic void run() {synchronized (object) {System.out.println("in " + this.getName());Thread.currentThread().suspend();}}}public static void main(String[] args) throws InterruptedException {T1 t1 = new T1("t1");t1.start();Thread.sleep(100);T1 t2 = new T1("t2");t2.start();t1.resume();t2.resume();t1.join();t2.join();}
}
运行代码输出：
in t1
in t2
我们会发现程序不会结束，线程t2被挂起了，导致程序无法结束，使用jstack命令查看线程堆栈信息可以看到：
"t2" #13 prio=5 os_prio=0 tid=0x000000002796c000 nid=0xa3c runnable [0x000000002867f000]java.lang.Thread.State: RUNNABLEat java.lang.Thread.suspend0(Native Method)at java.lang.Thread.suspend(Thread.java:1029)at com.itsoku.chat01.Demo07$T1.run(Demo07.java:20)- locked <0x0000000717372fc0> (a java.lang.Object)
发现t2线程在suspend0处被挂起了，t2的状态竟然还是RUNNABLE状态，线程明明被挂起了，状态还是运行中容易导致我们队当前系统进行误判，代码中已经调用resume()方法了，但是由于时间先后顺序的缘故，resume并没有生效，这导致了t2永远滴被挂起了，并且永远占用了object的锁，这对于系统来说可能是致命的。
6、等待线程结束（join）和谦让（yeild）
很多时候，一个线程的输入可能非常依赖于另外一个或者多个线程的输出，此时，这个线程就需要等待依赖的线程执行完毕，才能继续执行。jdk提供了join()操作来实现这个功能。如下所示，显示了2个join()方法：
public final void join() throws InterruptedException;
public final synchronized void join(long millis) throws InterruptedException;
第1个方法表示无限等待，它会一直只是当前线程。知道目标线程执行完毕。
第2个方法有个参数，用于指定等待时间，如果超过了给定的时间目标线程还在执行，当前线程也会停止等待，而继续往下执行。
比如：线程T1需要等待T2、T3完成之后才能继续执行，那么在T1线程中需要分别调用T2和T3的join()方法。
上个示例：
public class Demo08 {static int num = 0;public static class T1 extends Thread {public T1(String name) {super(name);}@Overridepublic void run() {System.out.println(System.currentTimeMillis() + ",start " + this.getName());for (int i = 0; i < 10; i++) {num++;try {Thread.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(System.currentTimeMillis() + ",end " + this.getName());}}public static void main(String[] args) throws InterruptedException {T1 t1 = new T1("t1");t1.start();t1.join();System.out.println(System.currentTimeMillis() + ",num = " + num);}
}
执行结果：
1562939889129,start t1
1562939891134,end t1
1562939891134,num = 10
num的结果为10，1、3行的时间戳相差2秒左右，说明主线程等待t1完成之后才继续执行的。
看一下jdk1.8中Thread.join()方法的实现：
public final synchronized void join(long millis) throws InterruptedException {long base = System.currentTimeMillis();long now = 0;if (millis < 0) {throw new IllegalArgumentException("timeout value is negative");}if (millis == 0) {while (isAlive()) {wait(0);}} else {while (isAlive()) {long delay = millis - now;if (delay <= 0) {break;}wait(delay);now = System.currentTimeMillis() - base;}}
}
从join的代码中可以看出，在被等待的线程上使用了synchronize，调用了它的wait()方法，线程最后执行完毕之后，系统会自动调用它的notifyAll()方法，唤醒所有在此线程上等待的其他线程。
注意：被等待的线程执行完毕之后，系统自动会调用该线程的notifyAll()方法。所以一般情况下，我们不要去在线程对象上使用wait()、notify()、notifyAll()方法。
另外一个方法是Thread.yield() ，他的定义如下：
public static native void yield();
yield是谦让的意思，这是一个静态方法，一旦执行，它会让当前线程出让CPU，但需要注意的是，出让CPU并不是说不让当前线程执行了，当前线程在出让CPU后，还会进行CPU资源的争夺，但是能否再抢到CPU的执行权就不一定了。因此，对Thread.yield()方法的调用好像就是在说：我已经完成了一些主要的工作，我可以休息一下了，可以让CPU给其他线程一些工作机会了。
如果觉得一个线程不太重要，或者优先级比较低，而又担心此线程会过多的占用CPU资源，那么可以在适当的时候调用一下Thread.yield()方法，给与其他线程更多的机会。
7、总结
- 创建线程的2中方式：继承Thread类；实现Runnable接口
- 启动线程：调用线程的start()方法
- 终止线程：调用线程的stop()方法，方法已过时，建议不要使用
- 线程中断相关的方法：调用线程实例interrupt()方法将中断标志置为true；使用线程实例方法isInterrupted() 获取中断标志；调用Thread的静态方法interrupted() 获取线程是否被中断，此方法调用之后会清除中断标志（将中断标志置为false了）
- wait、notify、notifyAll方法，这块比较难理解，可以回过头去再理理
- 线程挂起使用线程实例方法suspend() ，恢复线程使用线程实例方法resume() ，这2个方法都过时了，不建议使用
- 等待线程结束：调用线程实例方法join()
- 出让cpu资源：调用线程静态方法yeild()
③：为什么多线程极其重要？？？
- 硬件方面 - 摩尔定律失效
摩尔定律： 它是由英特尔创始人之一Gordon Moore(戈登·摩尔)提出来的。其内容为： 当价格不变时，集成电路上可容纳的元器件的数目约每隔18-24个月便会增加一倍，性能也将提升一倍。 换言之，每一美元所能买到的电脑性能，将每隔18-24个月翻一倍以上。这一定律揭示了信息技术进步的速度。
可是从2003年开始CPU主频已经不再翻倍，而是采用多核而不是更快的主频。
摩尔定律失效。
在主频不再提高且核数在不断增加的情况下，要想让程序更快就要用到并行或并发编程。
- 软件方面
高并发系统，异步+回调等生产需求
④：从start一个线程说起
// Java线程理解以及openjdk中的实现
private native void start0();
// Java语言本身底层就是C++语言
OpenJDK源码网址:/
openjdk8\hotspot\src\share\vm\runtime
更加底层的C++源码解读
openjdk8\jdk\src\share\native\java\lang thread.c
java线程是通过start的方法启动执行的，主要内容在native方法start0中，Openjdk的写JNI一般是一一对应的，Thread.java对应的就是Thread.c start0其实就是JVM_StartThread。此时查看源代码可以看到在jvm.h中找到了声明，jvm.cpp中有实现。
openjdk8\hotspot\src\share\vm\prims jvm.cpp
openjdk8\hotspot\src\share\vm\runtime thread.cpp
⑤：用户线程和守护线程
Java线程分为用户线程和守护线程，线程的daemon属性为true表示是守护线程，false表示是用户线程
1、守护线程
是一种特殊的线程，在后台默默地完成一些系统性的服务，比如垃圾回收线程
2、用户线程
是系统的工作线程，它会完成这个程序需要完成的业务操作
public class DaemonDemo {public static void main(String[] args) {Thread t1 = new Thread(() -> {System.out.println(Thread.currentThread().getName() + "\t 开始运行，" + (Thread.currentThread().isDaemon() ? "守护线程" : "用户线程"));while (true) {}}, "t1");//线程的daemon属性为true表示是守护线程，false表示是用户线程t1.setDaemon(true);t1.start();//3秒钟后主线程再运行try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("----------main线程运行完毕");}}
3、重点
当程序中所有用户线程执行完毕之后，不管守护线程是否结束，系统都会自动退出
如果用户线程全部结束了，意味着程序需要完成的业务操作已经结束了，系统可以退出了。所以当系统只剩下守护进程的时候，java虚拟机会自动退出
设置守护线程，需要在start() 方法之前进行
⑥：获得多线程的方法几种？
-
传统的是
- 继承thread类
- 实现runnable接口，
-
java5以后
- 实现callable接口
- java的线程池获得
⑦：Callable接口
1、与runnable对比
// 创建新类MyThread实现runnable接口
class MyThread implements Runnable{@Overridepublic void run() {}
}
// 新类MyThread2实现callable接口
class MyThread2 implements Callable<Integer>{@Overridepublic Integer call() throws Exception {return 200;}
}
// 面试题:callable接口与runnable接口的区别？// 答：（1）是否有返回值
// （2）是否抛异常
// （3）落地方法不一样，一个是run，一个是call
2、怎么用
直接替换runnable是否可行？
不可行，因为：thread类的构造方法根本没有Callable
认识不同的人找中间人
public static void main(String[] args) throws ExecutionException, InterruptedException {FutureTask futureTask = new FutureTask(new MyThread2());new Thread(futureTask,"AA").start();
}
运行成功后如何获得返回值？
public static void main(String[] args) throws ExecutionException, InterruptedException {FutureTask futureTask = new FutureTask(new MyThread2());new Thread(futureTask,"AA").start();System.out.println(futureTask.get());
}
⑧：应用
$\textcolor{Green}{1、应用之异步调用（案例1）} $
01. 需要等待结果
这时既可以使用同步处理，也可以使用异步来处理
join 实现（同步）
static int result = 0;
private static void test1() throws InterruptedException {log.debug("开始");Thread t1 = new Thread(() -> {log.debug("开始");sleep(1);log.debug("结束");result = 10;}, "t1");t1.start();t1.join();log.debug("结果为:{}", result);
}
输出
20:30:40.453 [main] c.TestJoin - 开始
20:30:40.541 [Thread-0] c.TestJoin - 开始
20:30:41.543 [Thread-0] c.TestJoin - 结束
20:30:41.551 [main] c.TestJoin - 结果为:10
评价
- 需要外部共享变量，不符合面向对象封装的思想
- 必须等待线程结束，不能配合线程池使用
1. Future 实现（同步）
private static void test2() throws InterruptedException, ExecutionException {log.debug("开始");FutureTask<Integer> result = new FutureTask<>(() -> {log.debug("开始");sleep(1);log.debug("结束");return 10;});new Thread(result, "t1").start();log.debug("结果为:{}", result.get());
}
输出
10:11:57.880 c.TestSync [main] - 开始
10:11:57.942 c.TestSync [t1] - 开始
10:11:58.943 c.TestSync [t1] - 结束
10:11:58.943 c.TestSync [main] - 结果为:10
评价
- 规避了使用 join 之前的缺点
- 可以方便配合线程池使用
private static void test3() throws InterruptedException, ExecutionException {ExecutorService service = Executors.newFixedThreadPool(1);log.debug("开始");Future<Integer> result = service.submit(() -> {log.debug("开始");sleep(1);log.debug("结束");return 10;});log.debug("结果为:{}, result 的类型:{}", result.get(), result.getClass());service.shutdown();
}
输出
10:17:40.090 c.TestSync [main] - 开始
10:17:40.150 c.TestSync [pool-1-thread-1] - 开始
10:17:41.151 c.TestSync [pool-1-thread-1] - 结束
10:17:41.151 c.TestSync [main] - 结果为:10, result 的类型:class java.util.concurrent.FutureTask
评价
- 仍然是 main 线程接收结果
- get 方法是让调用线程同步等待
2. 自定义实现（同步）
见模式篇：保护性暂停模式
3. CompletableFuture 实现（异步）
private static void test4() {// 进行计算的线程池ExecutorService computeService = Executors.newFixedThreadPool(1);// 接收结果的线程池ExecutorService resultService = Executors.newFixedThreadPool(1);log.debug("开始");CompletableFuture.supplyAsync(() -> {log.debug("开始");sleep(1);log.debug("结束");return 10;}, computeService).thenAcceptAsync((result) -> {log.debug("结果为:{}", result);}, resultService);
}
输出
10:36:28.114 c.TestSync [main] - 开始
10:36:28.164 c.TestSync [pool-1-thread-1] - 开始
10:36:29.165 c.TestSync [pool-1-thread-1] - 结束
10:36:29.165 c.TestSync [pool-2-thread-1] - 结果为:10
评价
- 可以让调用线程异步处理结果，实际是其他线程去同步等待
- 可以方便地分离不同职责的线程池
- 以任务为中心，而不是以线程为中心
4. BlockingQueue 实现（异步）
private static void test6() {ExecutorService consumer = Executors.newFixedThreadPool(1);ExecutorService producer = Executors.newFixedThreadPool(1);BlockingQueue<Integer> queue = new SynchronousQueue<>();log.debug("开始");producer.submit(() -> {log.debug("开始");sleep(1);log.debug("结束");try {queue.put(10);} catch (InterruptedException e) {e.printStackTrace();}});consumer.submit(() -> {try {Integer result = queue.take();log.debug("结果为:{}", result);} catch (InterruptedException e) {e.printStackTrace();}});
}
02. 不需等待结果
这时最好是使用异步来处理
1. 普通线程实现
@Slf4j(topic = "c.FileReader")
public class FileReader {public static void read(String filename) {int idx = filename.lastIndexOf(File.separator);String shortName = filename.substring(idx + 1);try (FileInputStream in = new FileInputStream(filename)) {long start = System.currentTimeMillis();log.debug("read [{}] start ...", shortName);byte[] buf = new byte[1024];int n = -1;do {n = in.read(buf);} while (n != -1);long end = System.currentTimeMillis();log.debug("read [{}] end ... cost: {} ms", shortName, end - start);} catch (IOException e) {e.printStackTrace();}}
}
没有用线程时，方法的调用是同步的：
@Slf4j(topic = "c.Sync")
public class Sync {public static void main(String[] args) {String fullPath = "E:\1.mp4";FileReader.read(fullPath);log.debug("do other things ...");}
}
输出
18:39:15 [main] c.FileReader - read [1.mp4] start ...
18:39:19 [main] c.FileReader - read [1.mp4] end ... cost: 4090 ms
18:39:19 [main] c.Sync - do other things ...
使用了线程后，方法的调用时异步的：
private static void test1() {new Thread(() -> FileReader.read(Constants.MP4_FULL_PATH)).start();log.debug("do other things ...");
}
输出
18:41:53 [main] c.Async - do other things ...
18:41:53 [Thread-0] c.FileReader - read [1.mp4] start ...
18:41:57 [Thread-0] c.FileReader - read [1.mp4] end ... cost: 4197 ms
2. 线程池实现
private static void test2() {ExecutorService service = Executors.newFixedThreadPool(1);service.execute(() -> FileReader.read(Constants.MP4_FULL_PATH));log.debug("do other things ...");service.shutdown();
}
输出
11:03:31.245 c.TestAsyc [main] - do other things ...
11:03:31.245 c.FileReader [pool-1-thread-1] - read [1.mp4] start ...
11:03:33.479 c.FileReader [pool-1-thread-1] - read [1.mp4] end ... cost: 2235 ms
3. CompletableFuture 实现
private static void test3() throws IOException {CompletableFuture.runAsync(() -> FileReader.read(Constants.MP4_FULL_PATH));log.debug("do other things ...");System.in.read();
}
输出
11:09:38.145 c.TestAsyc [main] - do other things ...
11:09:38.145 c.FileReader [ForkJoinPoolmonPool-worker-1] - read [1.mp4] start ...
11:09:40.514 c.FileReader [ForkJoinPoolmonPool-worker-1] - read [1.mp4] end ... cost: 2369 ms
以调用方角度来讲，
- 如果 需要等待结果返回，才能继续运行就是同步
- 不需要等待结果返回，就能继续运行就是异步
1.设计
多线程可以让方法执行变为异步的（即不要巴巴干等着）、比如说读取磁盘文件时，假设读取操作花费了 5 秒钟，如果没有线程调度机制，这 5 秒 cpu 什么都做不了，其它代码都得暂停…
2.结论
- 比如在项目中，视频文件需要转换格式等操作比较费时，这时开一个新线程处理视频转换，避免阻塞主线程
- tomcat 的异步 servlet 也是类似的目的，让用户线程处理耗时较长的操作，避免阻塞 tomcat 的工作线程
- ui 程序中，开线程进行其他操作，避免阻塞 ui 线程
2 、应用之提高效率（案例 1 ） \textcolor{Green}{2、应用之提高效率（案例1） } 2、应用之提高效率（案例1）
充分利用多核 cpu 的优势，提高运行效率。想象下面的场景，执行 3 个计算，最后将计算结果汇总。
计算 1 花费 10 ms
计算 2 花费 11 ms
计算 3 花费 9 ms
汇总需要 1 ms
- 如果是串行执行，那么总共花费的时间是 10 + 11 + 9 + 1 = 31ms
- 但如果是四核 cpu，各个核心分别使用线程 1 执行计算 1，线程 2 执行计算 2，线程 3 执行计算 3，那么 3 个 线程是并行的，花费时间只取决于最长的那个线程运行的时间，即 11ms 最后加上汇总时间只会花费 12ms
注意：
需要在多核 cpu 才能提高效率，单核仍然时是轮流执行
01.设计
代码见【应用之效率-案例1】
02.结论
-
单核 cpu 下，多线程不能实际提高程序运行效率，只是为了能够在不同的任务之间切换，不同线程轮流使用 cpu ，不至于一个线程总占用 cpu，别的线程没法干活
-
多核 cpu 可以并行跑多个线程，但能否提高程序运行效率还是要分情况的
- 有些任务，经过精心设计，将任务拆分，并行执行，当然可以提高程序的运行效率。但不是所有计算任 务都能拆分（参考后文的【阿姆达尔定律】）
- 也不是所有任务都需要拆分，任务的目的如果不同，谈拆分和效率没啥意义
-
IO 操作不占用 cpu，只是我们一般拷贝文件使用的是【阻塞 IO】，这时相当于线程虽然不用 cpu，但需要一 直等待 IO 结束，没能充分利用线程。所以才有后面的【非阻塞 IO】和【异步 IO】优化。
二、Java 线程
①： 创建和运行线程
1、方法一，直接使用 Thread
// 创建线程对象
Thread t = new Thread() {public void run() {// 要执行的任务}
};
// 启动线程
t.start();
例如：
// 构造方法的参数是给线程指定名字，推荐
Thread t1 = new Thread("t1") {@Override// run 方法内实现了要执行的任务public void run() {log.debug("hello");}
};
t1.start();
输出：
19:19:00 [t1] c.ThreadStarter - hello
2、方法二，使用 Runnable 配合 Thread
把【线程】和【任务】（要执行的代码）分开
- Thread 代表线程
- Runnable 可运行的任务（线程要执行的代码）
Runnable runnable = new Runnable() {public void run(){// 要执行的任务}
};
// 创建线程对象
Thread t = new Thread( runnable );
// 启动线程
t.start();
例如：
// 创建任务对象
Runnable task2 = new Runnable() {@Overridepublic void run() {log.debug("hello");}
};
// 参数1 是任务对象; 参数2 是线程名字，推荐
Thread t2 = new Thread(task2, "t2");
t2.start();
输出：
9:19:00 [t2] c.ThreadStarter - hello
Java 8 以后可以使用 lambda 精简代码
// 创建任务对象
Runnable task2 = () -> log.debug("hello");
// 参数1 是任务对象; 参数2 是线程名字，推荐
Thread t2 = new Thread(task2, "t2");
t2.start();
01. Thread 与 Runnable 的关系
分析 Thread 的源码，理清它与 Runnable 的关系
//Runnable源码
public interface Runnable {public abstract void run();
}
//Thread源码（部分）
public class Thread implements Runnable {/* What will be run. */private Runnable target;public Thread(Runnable target) {init(null, target, "Thread-" + nextThreadNum(), 0);}private void init(ThreadGroup g, Runnable target, String name,long stackSize, AccessControlContext acc,boolean inheritThreadLocals) {//...this.target = target;//...}@Overridepublic void run() {if (target != null) {target.run();}}
02. 小结
- 方法1 是把线程和任务合并在了一起，方法2 是把线程和任务分开了
- 用 Runnable 更容易与线程池等高级API 配合
- 用 Runnable 让任务类脱离了 Thread 继承体系，更灵活
3、方法三，FutureTask 配合 Thread
FutureTask 能够接收 Callable 类型的参数，用来处理有返回结果的情况
// 创建任务对象
FutureTask<Integer> task3 = new FutureTask<>(() -> {log.debug("hello");return 100;
});
// 参数1 是任务对象; 参数2 是线程名字，推荐
new Thread(task3, "t3").start();
// 主线程阻塞，同步等待 task 执行完毕的结果
Integer result = task3.get();
log.debug("结果是:{}", result);
输出
19:22:27 [t3] c.ThreadStarter - hello
19:22:27 [main] c.ThreadStarter - 结果是:100
源码分析
//FutureTask源码（部分）
public class FutureTask<V> implements RunnableFuture<V> {/** The underlying callable; nulled out after running */private Callable<V> callable;/** The result to return or exception to throw from get() */private Object outcome; // non-volatile, protected by state reads/writespublic FutureTask(Callable<V> callable) {if (callable == null)throw new NullPointerException();this.callable = callable;this.state = NEW; // ensure visibility of callable}public void run() {//...try {Callable<V> c = callable;if (c != null && state == NEW) {V result;boolean ran;try {result = c.call();ran = true;} catch (Throwable ex) {result = null;ran = false;setException(ex);}if (ran)set(result);}}//...}protected void set(V v) {if (UNSAFEpareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {outcome = v;UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final statefinishCompletion();}}public V get() throws InterruptedException, ExecutionException {int s = state;if (s <= COMPLETING)s = awaitDone(false, 0L);return report(s);}private V report(int s) throws ExecutionException {Object x = outcome;if (s == NORMAL)return (V)x;if (s >= CANCELLED)throw new CancellationException();throw new ExecutionException((Throwable)x);}
}
//Callable源码
@FunctionalInterface
public interface Callable<V> {/*** Computes a result, or throws an exception if unable to do so.** @return computed result* @throws Exception if unable to compute a result*/V call() throws Exception;
}
说明：
- FutureTask内置了一个Callable对象，初始化方法将指定的Callable赋给这个对象。
- FutureTask实现了Runnable接口，并重写了Run方法，在Run方法中调用了Callable中的call方法，并将返回值赋值给outcome变量
- get方法就是取出outcome的值。
②： 观察多个线程同时运行
主要是理解
- 交替执行
- 谁先谁后，不由我们控制
示例代码
@Slf4j(topic = "c.TestMultiThread")
public class TestMultiThread {public static void main(String[] args) {new Thread(() -> {while(true) {log.debug("running");}},"t1").start();new Thread(() -> {while(true) {log.debug("running");}},"t2").start();}
}
运行结果：
23:45:26.254 c.TestMultiThread [t2] - running
23:45:26.254 c.TestMultiThread [t2] - running
23:45:26.254 c.TestMultiThread [t2] - running
23:45:26.254 c.TestMultiThread [t2] - running
23:45:26.254 c.TestMultiThread [t1] - running
23:45:26.254 c.TestMultiThread [t1] - running
23:45:26.254 c.TestMultiThread [t1] - running
23:45:26.254 c.TestMultiThread [t1] - running
23:45:26.254 c.TestMultiThread [t1] - running
23:45:26.254 c.TestMultiThread [t1] - running
③： 查看进程线程的方法
1、windows
-
任务管理器可以查看进程和线程数，也可以用来杀死进程
-
tasklist 查看进程
tasklist|findstr(查找关键字)
-
taskkill 杀死进程
- taskkill /F(彻底杀死）/PID(进程PID)
2、Linux
- ps -fe 查看所有进程
- ps -fT -p 查看某个进程（PID）的所有线程
- kill 杀死进程 top 按大写 H 切换是否显示线程
- top -H -p 查看某个进程（PID）的所有线程
3、Java
- jps 命令查看所有 Java 进程
- jstack 查看某个 Java 进程（PID）的所有线程状态
- jconsole 来查看某个 Java 进程中线程的运行情况（图形界面）
jconsole 远程监控配置
-
需要以如下方式运行你的 java 类
java -Djava.rmi.server.hostname=`ip地址` -Dcom.sun.management.jmxremote - Dcom.sun.management.jmxremote.port=`连接端口` -Dcom.sun.management.jmxremote.ssl=是否安全连接 - Dcom.sun.management.jmxremote.authenticate=是否认证 java类 -
关闭防火墙，允许端口
-
修改 /etc/hosts 文件将 127.0.0.1 映射至主机名
如果要认证访问，还需要做如下步骤
- 复制 jmxremote.password 文件
- 修改 jmxremote.password 和 jmxremote.access 文件的权限为 600 即文件所有者可读写
- 连接时填入 controlRole（用户名），R&D（密码）
$\textcolor{Blue}{④： 原理之线程运行} $
1、栈与栈帧
Java Virtual Machine Stacks （Java 虚拟机栈）
我们都知道 JVM 中由堆、栈、方法区所组成，其中栈内存是给谁用的呢？其实就是线程，每个线程启动后，虚拟 机就会为其分配一块栈内存。
- 每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存
- 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法
2、线程上下文切换（Thread Context Switch）
因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码
- 线程的 cpu 时间片用完
- 垃圾回收
- 有更高优先级的线程需要运行
- 线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法
当 Context Switch 发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java 中对应的概念 就是程序计数器（Program Counter Register），它的作用是记住下一条 jvm 指令的执行地址，是线程私有的
- 状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等
- Context Switch 频繁发生会影响性能
⑤：常见方法
| 方法 | 功能 | 说明 |
|---|---|---|
| public void start() | 启动一个新线程；Java虚拟机调用此线程的run方法 | start 方法只是让线程进入就绪，里面代码不一定立刻 运行（CPU 的时间片还没分给它）。每个线程对象的 start方法只能调用一次，如果调用了多次会出现 IllegalThreadStateException |
| public void run() | 线程启动后调用该方法 | 如果在构造 Thread 对象时传递了 Runnable 参数，则 线程启动后会调用 Runnable 中的 run 方法，否则默 认不执行任何操作。但可以创建 Thread 的子类对象， 来覆盖默认行为 |
| public void setName(String name) | 给当前线程取名字 | |
| public void getName() | 获取当前线程的名字。线程存在默认名称：子线程是Thread-索引，主线程是main | |
| public static Thread currentThread() | 获取当前线程对象，代码在哪个线程中执行 | |
| public static void sleep(long time) | 让当前线程休眠多少毫秒再继续执行。Thread.sleep(0) : 让操作系统立刻重新进行一次cpu竞争 | |
| public static native void yield() | 提示线程调度器让出当前线程对CPU的使用 | 主要是为了测试和调试 |
| public final int getPriority() | 返回此线程的优先级 | |
| public final void setPriority(int priority) | 更改此线程的优先级，常用1 5 10 | java中规定线程优先级是1~10 的整数，较大的优先级 能提高该线程被 CPU 调度的机率 |
| public void interrupt() | 中断这个线程，异常处理机制 | |
| public static boolean interrupted() | 判断当前线程是否被打断，清除打断标记 | |
| public boolean isInterrupted() | 判断当前线程是否被打断，不清除打断标记 | |
| public final void join() | 等待这个线程结束 | |
| public final void join(long millis) | 等待这个线程死亡millis毫秒，0意味着永远等待 | |
| public final native boolean isAlive() | 线程是否存活（还没有运行完毕） | |
| public final void setDaemon(boolean on) | 将此线程标记为守护线程或用户线程 | |
| public long getId() | 获取线程长整型 的 id | id 唯一 |
| public state getState() | 获取线程状态 | Java 中线程状态是用 6 个 enum 表示，分别为： NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED |
| public boolean isInterrupted() | 判断是否被打 断 | 不会清除 打断标记 |
⑥： start 与 run
1、调用 run
public static void main(String[] args) {Thread t1 = new Thread("t1") {@Overridepublic void run() {log.debug(Thread.currentThread().getName());FileReader.read(Constants.MP4_FULL_PATH);}};t1.run();log.debug("do other things ...");
}
输出
19:39:14 [main] c.TestStart - main
19:39:14 [main] c.FileReader - read [1.mp4] start ...
19:39:18 [main] c.FileReader - read [1.mp4] end ... cost: 4227 ms
19:39:18 [main] c.TestStart - do other things ...
程序仍在 main 线程运行， FileReader.read() 方法调用还是同步的
2、调用start
将上述代码的 t1.run() 改为
t1.start();
输出
19:41:30 [main] c.TestStart - do other things ...
19:41:30 [t1] c.TestStart - t1
19:41:30 [t1] c.FileReader - read [1.mp4] start ...
19:41:35 [t1] c.FileReader - read [1.mp4] end ... cost: 4542 ms
程序在 t1 线程运行， FileReader.read() 方法调用是异步的
3、3小结
-
直接调用 run 是在主线程中执行了 run，没有启动新的线程
-
使用 start 是启动新的线程，通过新的线程间接执行 run 中的代码
public static void main(String[] args) {Thread t1 = new Thread("t1") {@Overridepublic void run() {log.debug("running...");}};System.out.println(t1.getState());t1.start();System.out.println(t1.getState()); }可以看见，start方法创建了一个新线程，将线程从就绪状态切换为Runnable
NEW RUNNABLE 03:45:12.255 c.Test5 [t1] - running...
⑦： sleep 与 yield
1、sleep
-
调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
-
其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException
public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread("t1") {@Overridepublic void run() {log.debug("enter sleep...");try {Thread.sleep(2000);} catch (InterruptedException e) {log.debug("wake up...");e.printStackTrace();}}};t1.start();Thread.sleep(1000);log.debug("interrupt...");t1.interrupt(); }输出结果：
03:47:18.141 c.Test7 [t1] - enter sleep... 03:47:19.132 c.Test7 [main] - interrupt... 03:47:19.132 c.Test7 [t1] - wake up... java.lang.InterruptedException: sleep interruptedat java.lang.Thread.sleep(Native Method)at cn.itcast.test.Test7$1.run(Test7.java:14) -
睡眠结束后的线程未必会立刻得到执行
-
建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性 。其底层还是sleep方法。
@Slf4j(topic = "c.Test8") public class Test8 {public static void main(String[] args) throws InterruptedException {log.debug("enter");TimeUnit.SECONDS.sleep(1);log.debug("end"); // Thread.sleep(1000);} } -
在循环访问锁的过程中，可以加入sleep让线程阻塞时间，防止大量占用cpu资源。
2、yield
- 调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程
- 具体的实现依赖于操作系统的任务调度器
3、线程优先级
- 线程优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它
- 如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用
4、测试优先级和yield
@Slf4j(topic = "c.TestYield")
public class TestYield {public static void main(String[] args) {Runnable task1 = () -> {int count = 0;for (;;) {System.out.println("---->1 " + count++);}};Runnable task2 = () -> {int count = 0;for (;;) {
// Thread.yield();System.out.println(" ---->2 " + count++);}};Thread t1 = new Thread(task1, "t1");Thread t2 = new Thread(task2, "t2");t1.setPriority(Thread.MIN_PRIORITY);t2.setPriority(Thread.MAX_PRIORITY);t1.start();t2.start();}
}
测试结果：
#优先级
---->1 283500
---->2 374389
#yield
---->1 119199
---->2 101074
可以看出，线程优先级和yield会对线程获取cpu时间片产生一定影响，但不会影响太大。
$\textcolor{Green}{*5、应用之限制（案例1） } $
01. sleep 实现
在没有利用 cpu 来计算时，不要让 while(true) 空转浪费 cpu，这时可以使用 yield 或 sleep 来让出 cpu 的使用权 给其他程序
while(true) {try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}
}
- 可以用 wait 或 条件变量达到类似的效果
- 不同的是，后两种都需要加锁，并且需要相应的唤醒操作，一般适用于要进行同步的场景
- sleep 适用于无需锁同步的场景
02. wait 实现
synchronized(锁对象) {while(条件不满足) { try {锁对象.wait();} catch(InterruptedException e) {e.printStackTrace();}}// do sth...
}
03. 条件变量实现
lock.lock();
try {while(条件不满足) {try {条件变量.await();} catch (InterruptedException e) {e.printStackTrace();}}// do sth...
} finally {lock.unlock();
}
⑧： join 方法详解
1、为什么需要 join
下面的代码执行，打印 r 是什么？
static int r = 0;
public static void main(String[] args) throws InterruptedException {test1();
}
private static void test1() throws InterruptedException {log.debug("开始");Thread t1 = new Thread(() -> {log.debug("开始");sleep(1);log.debug("结束");r = 10;});t1.start();log.debug("结果为:{}", r);log.debug("结束");
}
分析
- 因为主线程和线程 t1 是并行执行的，t1 线程需要 1 秒之后才能算出 r=10
- 而主线程一开始就要打印 r 的结果，所以只能打印出 r=0
解决方法
- 用 sleep 行不行？为什么？
- 用 join，加在 t1.start() 之后即可
∗ 2 、应用之同步（案例 1 ） \textcolor{green}{*2、应用之同步（案例1）} ∗2、应用之同步（案例1）
以调用方角度来讲，如果
- 需要等待结果返回，才能继续运行就是同步
- 不需要等待结果返回，就能继续运行就是异步
等待多个结果
问，下面代码 cost 大约多少秒？
static int r1 = 0;
static int r2 = 0;
public static void main(String[] args) throws InterruptedException {test2();
}
private static void test2() throws InterruptedException {Thread t1 = new Thread(() -> {sleep(1);r1 = 10;});Thread t2 = new Thread(() -> {sleep(2);r2 = 20;});long start = System.currentTimeMillis();t1.start();t2.start();t1.join();t2.join();long end = System.currentTimeMillis();log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
}
分析如下
- 第一个 join：等待 t1 时, t2 并没有停止, 而在运行
- 第二个 join：1s 后, 执行到此, t2 也运行了 1s, 因此也只需再等待 1s
如果颠倒两个 join 呢？
最终都是输出
20:45:43.239 [main] c.TestJoin - r1: 10 r2: 20 cost: 2005
3、有时效的join
当线程执行时间没有超过join设定时间
static int r1 = 0;
static int r2 = 0;
public static void main(String[] args) throws InterruptedException {test3();
}
public static void test3() throws InterruptedException {Thread t1 = new Thread(() -> {sleep(1);r1 = 10;});long start = System.currentTimeMillis();t1.start();// 线程执行结束会导致 join 结束t1.join(1500);long end = System.currentTimeMillis();log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
}
输出
20:48:01.320 [main] c.TestJoin - r1: 10 r2: 0 cost: 1010
当执行时间超时
static int r1 = 0;
static int r2 = 0;
public static void main(String[] args) throws InterruptedException {test3();
}
public static void test3() throws InterruptedException {Thread t1 = new Thread(() -> {sleep(2);r1 = 10;});long start = System.currentTimeMillis();t1.start();// 线程执行结束会导致 join 结束t1.join(1500);long end = System.currentTimeMillis();log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
}
输出
20:52:15.623 [main] c.TestJoin - r1: 0 r2: 0 cost: 1502
⑨： interrupt方法详解
1、Interrupt说明
interrupt的本质是将线程的打断标记设为true，并调用线程的三个parker对象（C++实现级别）unpark该线程。
基于以上本质，有如下说明：
-
打断线程不等于中断线程，有以下两种情况：
- 打断正在运行中的线程并不会影响线程的运行，但如果线程监测到了打断标记为true，可以自行决定后续处理。
- 打断阻塞中的线程会让此线程产生一个
InterruptedException异常，结束线程的运行。但如果该异常被线程捕获住，该线程依然可以自行决定后续处理（终止运行，继续运行，做一些善后工作等等）
2、打断 sleep，wait，join 的线程
这几个方法都会让线程进入阻塞状态
打断 sleep 的线程, 会清空打断状态，以 sleep 为例
private static void test1() throws InterruptedException {Thread t1 = new Thread(()->{sleep(1);}, "t1");t1.start();sleep(0.5);t1.interrupt();log.debug(" 打断状态: {}", t1.isInterrupted());
}
输出
java.lang.InterruptedException: sleep interruptedat java.lang.Thread.sleep(Native Method)at java.lang.Thread.sleep(Thread.java:340)at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)at cn.itcast.n2.util.Sleeper.sleep(Sleeper.java:8)at cn.itcast.n4.TestInterrupt.lambda$test1$3(TestInterrupt.java:59)at java.lang.Thread.run(Thread.java:745)
21:18:10.374 [main] c.TestInterrupt - 打断状态: false
3、打断正常运行的线程
打断正常运行的线程, 不会清空打断状态
private static void test2() throws InterruptedException {Thread t2 = new Thread(()->{while(true) {Thread current = Thread.currentThread();boolean interrupted = current.isInterrupted();if(interrupted) {log.debug(" 打断状态: {}", interrupted);break;}}}, "t2");t2.start();sleep(0.5);t2.interrupt();
}
输出
20:57:37.964 [t2] c.TestInterrupt - 打断状态: true
*4、模式之两阶段终止
Two Phase Termination 在一个线程 T1 中如何“优雅”终止线程 T2？这里的【优雅】指的是给 T2 一个料理后事的机会。
01. 错误思路
-
使用线程对象的 stop() 方法停止线程
- stop 方法会真正杀死线程，如果这时线程锁住了共享资源，那么当它被杀死后就再也没有机会释放锁， 其它线程将永远无法获取锁
-
使用 System.exit(int) 方法停止线程
- 目的仅是停止一个线程，但这种做法会让整个程序都停止
02. 两阶段终止模式
1. 利用 isInterrupted
interrupt 可以打断正在执行的线程，无论这个线程是在 sleep，wait，还是正常运行
class TPTInterrupt {private Thread thread;public void start(){thread = new Thread(() -> {while(true) {Thread current = Thread.currentThread();if(current.isInterrupted()) {log.debug("料理后事");break;}try {Thread.sleep(1000);log.debug("将结果保存");} catch (InterruptedException e) {current.interrupt();}// 执行监控操作 }},"监控线程");thread.start();}public void stop() {thread.interrupt();}
}
调用
TPTInterrupt t = new TPTInterrupt();
t.start();
Thread.sleep(3500);
log.debug("stop");
t.stop();
结果
11:49:42.915 c.TwoPhaseTermination [监控线程] - 将结果保存
11:49:43.919 c.TwoPhaseTermination [监控线程] - 将结果保存
11:49:44.919 c.TwoPhaseTermination [监控线程] - 将结果保存
11:49:45.413 c.TestTwoPhaseTermination [main] - stop
11:49:45.413 c.TwoPhaseTermination [监控线程] - 料理后事
2. 利用停止标记
// 停止标记用 volatile 是为了保证该变量在多个线程之间的可见性
// 我们的例子中，即主线程把它修改为 true 对 t1 线程可见
class TPTVolatile {private Thread thread;private volatile boolean stop = false;public void start(){thread = new Thread(() -> {while(true) {Thread current = Thread.currentThread();if(stop) {log.debug("料理后事");break;}try {Thread.sleep(1000);log.debug("将结果保存");} catch (InterruptedException e) {}// 执行监控操作}},"监控线程");thread.start();}public void stop() {stop = true;thread.interrupt();}
}
调用
TPTVolatile t = new TPTVolatile();
t.start();
Thread.sleep(3500);
log.debug("stop");
t.stop();
结果
11:54:52.003 c.TPTVolatile [监控线程] - 将结果保存
11:54:53.006 c.TPTVolatile [监控线程] - 将结果保存
11:54:54.007 c.TPTVolatile [监控线程] - 将结果保存
11:54:54.502 c.TestTwoPhaseTermination [main] - stop
11:54:54.502 c.TPTVolatile [监控线程] - 料理后事
5、打断 park 线程
打断 park 线程, 不会清空打断状态
private static void test3() throws InterruptedException {Thread t1 = new Thread(() -> {log.debug("park...");LockSupport.park();log.debug("unpark...");log.debug("打断状态：{}", Thread.currentThread().isInterrupted());}, "t1");t1.start();sleep(0.5);t1.interrupt();
}
输出
21:11:52.795 [t1] c.TestInterrupt - park...
21:11:53.295 [t1] c.TestInterrupt - unpark...
21:11:53.295 [t1] c.TestInterrupt - 打断状态：true
如果打断标记已经是 true, 则 park 会失效
private static void test4() {Thread t1 = new Thread(() -> {for (int i = 0; i < 5; i++) {log.debug("park...");LockSupport.park();log.debug("打断状态：{}", Thread.currentThread().isInterrupted());}});t1.start();sleep(1);t1.interrupt();
}
输出
21:13:48.783 [Thread-0] c.TestInterrupt - park...
21:13:49.809 [Thread-0] c.TestInterrupt - 打断状态：true
21:13:49.812 [Thread-0] c.TestInterrupt - park...
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true
21:13:49.813 [Thread-0] c.TestInterrupt - park...
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true
21:13:49.813 [Thread-0] c.TestInterrupt - park...
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true
21:13:49.813 [Thread-0] c.TestInterrupt - park...
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true
提示
可以使用 Thread.interrupted() 清除打断状态
⑩： 不推荐的方法
还有一些不推荐使用的方法，这些方法已过时，容易破坏同步代码块，造成线程死锁
| 方法名 | static | 功能说明 |
|---|---|---|
| stop() | 停止线程运行 | |
| suspend() | 挂起（暂停）线程运行 | |
| resume() | 恢复线程运行 |
⑩①： 主线程与守护线程
默认情况下，Java 进程需要等待所有线程都运行结束，才会结束。有一种特殊的线程叫做守护线程，只要其它非守护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。
例:
log.debug("开始运行...");
Thread t1 = new Thread(() -> {log.debug("开始运行...");sleep(2);log.debug("运行结束...");
}, "daemon");
// 设置该线程为守护线程
t1.setDaemon(true);
t1.start();
sleep(1);
log.debug("运行结束...");
输出：
08:26:38.123 [main] c.TestDaemon - 开始运行...
08:26:38.213 [daemon] c.TestDaemon - 开始运行...
08:26:39.215 [main] c.TestDaemon - 运行结束...
注意
- 垃圾回收器线程就是一种守护线程
- Tomcat 中的 Acceptor 和 Poller 线程都是守护线程，所以 Tomcat 接收到 shutdown 命令后，不会等待它们处理完当前请求
⑩②： 五种状态
这是从 操作系统 层面来描述的
-
【初始状态】仅是在语言层面创建了线程对象，还未与操作系统线程关联
-
【可运行状态】（就绪状态）指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行
-
【运行状态】指获取了 CPU 时间片运行中的状态
- 当 CPU 时间片用完，会从【运行状态】转换至【可运行状态】，会导致线程的上下文切换
-
【阻塞状态】
- 如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU，会导致线程上下文切换，进入 【阻塞状态】
- 等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】
- 与【可运行状态】的区别是，对【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑 调度它们
-
【终止状态】表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态
⑩③： 六种状态
这是从 Java API 层面来描述的
根据 Thread.State 枚举，分为六种状态
- NEW 线程刚被创建，但是还没有调用 start() 方法
- RUNNABLE 当调用了 start() 方法之后，注意，Java API 层面的 RUNNABLE 状态涵盖了 操作系统 层面的 【可运行状态】、【运行状态】和【阻塞状态】（由于 BIO 导致的线程阻塞，在 Java 里无法区分，仍然认为 是可运行）
- BLOCKED ， WAITING ， TIMED_WAITING 都是 Java API 层面对【阻塞状态】的细分，后面会在状态转换一节 详述
- TERMINATED 当线程代码运行结束
⑩④： 习题
阅读华罗庚《统筹方法》，给出烧水泡茶的多线程解决方案，提示
-
参考图二，用两个线程（两个人协作）模拟烧水泡茶过程
- 文中办法乙、丙都相当于任务串行
- 而图一相当于启动了 4 个线程，有点浪费
-
用 sleep(n) 模拟洗茶壶、洗水壶等耗费的时间
∗ 1 、应用之统筹（烧水泡茶） \textcolor{green}{*1、应用之统筹（烧水泡茶）} ∗1、应用之统筹（烧水泡茶）
01. 解法1：join
Thread t1 = new Thread(() -> {log.debug("洗水壶");sleep(1);log.debug("烧开水");sleep(15);
}, "老王");
Thread t2 = new Thread(() -> {log.debug("洗茶壶");sleep(1);log.debug("洗茶杯");sleep(2);log.debug("拿茶叶");sleep(1);try {t1.join();。} catch (InterruptedException e) {e.printStackTrace();}log.debug("泡茶");
}, "小王");
t1.start();
t2.start();
输出
19:19:37.547 [小王] c.TestMakeTea - 洗茶壶
19:19:37.547 [老王] c.TestMakeTea - 洗水壶
19:19:38.552 [小王] c.TestMakeTea - 洗茶杯
19:19:38.552 [老王] c.TestMakeTea - 烧开水
19:19:40.553 [小王] c.TestMakeTea - 拿茶叶
19:19:53.553 [小王] c.TestMakeTea - 泡茶
解法1 的缺陷：
- 上面模拟的是小王等老王的水烧开了，小王泡茶，如果反过来要实现老王等小王的茶叶拿来了，老王泡茶 呢？代码最好能适应两种情况
- 上面的两个线程其实是各执行各的，如果要模拟老王把水壶交给小王泡茶，或模拟小王把茶叶交给老王泡茶 呢
02. 解法2：wait/notify
class S2 {static String kettle = "冷水";static String tea = null;static final Object lock = new Object();static boolean maked = false;public static void makeTea() {new Thread(() -> {log.debug("洗水壶");sleep(1);log.debug("烧开水");sleep(5);synchronized (lock) {kettle = "开水";lock.notifyAll();while (tea == null) {try {lock.wait();} catch (InterruptedException e) {e.printStackTrace();}}if (!maked) {log.debug("拿({})泡({})", kettle, tea);maked = true;}}}, "老王").start();new Thread(() -> {log.debug("洗茶壶");sleep(1);log.debug("洗茶杯");sleep(2);log.debug("拿茶叶");sleep(1);synchronized (lock) {tea = "花茶";lock.notifyAll();while (kettle.equals("冷水")) {try {lock.wait();} catch (InterruptedException e) {e.printStackTrace();}}if (!maked) {log.debug("拿({})泡({})", kettle, tea);maked = true;}}}, "小王").start();}
}
输出
20:04:48.179 c.S2 [小王] - 洗茶壶
20:04:48.179 c.S2 [老王] - 洗水壶
20:04:49.185 c.S2 [老王] - 烧开水
20:04:49.185 c.S2 [小王] - 洗茶杯
20:04:51.185 c.S2 [小王] - 拿茶叶
20:04:54.185 c.S2 [老王] - 拿(开水)泡(花茶)
解法2 解决了解法1 的问题，不过老王和小王需要相互等待，不如他们只负责各自的任务，泡茶交给第三人来做
class S3 {static String kettle = "冷水";static String tea = null;static final Object lock = new Object();public static void makeTea() {new Thread(() -> {log.debug("洗水壶");sleep(1);log.debug("烧开水");sleep(5);synchronized (lock) {kettle = "开水";lock.notifyAll();}}, "老王").start();new Thread(() -> {log.debug("洗茶壶");sleep(1);log.debug("洗茶杯");sleep(2);log.debug("拿茶叶");sleep(1);synchronized (lock) {tea = "花茶";lock.notifyAll();}}, "小王").start();new Thread(() -> {synchronized (lock) {while (kettle.equals("冷水") || tea == null) {try {lock.wait();} catch (InterruptedException e) {e.printStackTrace();}}log.debug("拿({})泡({})", kettle, tea);}}, "王夫人").start();}
}
输出
20:13:18.202 c.S3 [小王] - 洗茶壶
20:13:18.202 c.S3 [老王] - 洗水壶
20:13:19.206 c.S3 [小王] - 洗茶杯
20:13:19.206 c.S3 [老王] - 烧开水
20:13:21.206 c.S3 [小王] - 拿茶叶
20:13:24.207 c.S3 [王夫人] - 拿(开水)泡(花茶)
03. 解法3：第三者协调
⑩⑤：本章小结
本章的重点在于掌握
-
线程创建
-
线程重要 api，如 start，run，sleep，join，interrupt 等
-
线程状态
-
应用方面
- 异步调用：主线程执行期间，其它线程异步执行耗时操作
- 提高效率：并行计算，缩短运算时间
- 同步等待：join
- 统筹规划：合理使用线程，得到最优效果
-
原理方面
- 线程运行流程：栈、栈帧、上下文切换、程序计数器
- Thread 两种创建方式 的源码
-
模式方面
- 终止模式之两阶段终止
更多推荐
JUC并发编程1（线程基础 + Java线程）
发布评论