第二章 - 线程的创建

文章目录

第二章 - 线程的创建
1、创建和运行线程
- 方法一：直接使用Thread
- 方法二：使用Runnable配合Thread (推荐)
- - 方法二的简化：使用lambda表达式简化操作
  - 原理之 Thread 与 Runnable 的关系
- 方法三：使用FutureTask与Thread结合
2、原理之线程运行
- 栈与栈帧
- 线程上下文切换（Thread Context Switch）
3、常用方法
- start( ) 与 run( )
- - 调用start
  - 调用run
  - 小结
- sleep( ) 与 yield( )
- - sleep (使线程阻塞)
  - yield （让出当前线程）
  - sleep 和 yield区别
  - 线程优先级
- 应用 - sleep防止cpu占用100%
- join 方法详解
- 应用之同步（案例1）
- - 等待多个结果
  - 有时效的 join
- interrupt 方法详解
- - 打断 sleep，wait，join 的线程
  - 打断正常运行的线程
  - interrupt方法的应用——两阶段终止模式
  - 打断 park 线程
  - 不推荐使用的打断方法
- 主线程与守护线程
4、五种状态
5、六种状态
6、习题
- 应用之统筹（烧水泡茶）
本章小结

1、创建和运行线程

方法一：直接使用Thread

public class CreateThread {public static void main(String[] args) {// 创建线程对象Thread myThread = new MyThread();// 启动线程myThread.start();}
}class MyThread extends Thread {@Overridepublic void run() {System.out.println("my thread running...");}
}

使用继承方式的好处是：在run( ) 方法内获取当前线程直接使用this就可以了，无须使用Thread.currentThread( ) 方法；不好的地方是Java不支持多继承，如果继承了Thread类，那么就不能再继承其他类。另外任务与代码没有分离，当多个线程执行一样的任务时需要多份任务代码

方法二：使用Runnable配合Thread (推荐)

public class Test2 {public static void main(String[] args) {//创建线程任务Runnable r = new Runnable() {@Overridepublic void run() {System.out.println("Runnable running");}};//将Runnable对象传给ThreadThread t = new Thread(r);//启动线程t.start();}
}

或者

public class CreateThread2 {private static class MyRunnable implements Runnable {@Overridepublic void run() {System.out.println("my runnable running...");}}public static void main(String[] args) {MyRunnable myRunnable = new MyRunnable();Thread thread = new Thread(myRunnable);thread.start();}
}

通过实现Runnable接口，并且实现run( )方法。在创建线程时作为参数传入该类的实例即可

方法二的简化：使用lambda表达式简化操作

当一个接口带有@FunctionalInterface注解时，是可以使用lambda表达式来简化操作的

所以方法二中的代码可以被简化为

public class Test2 {public static void main(String[] args) {//创建线程任务Runnable r = () -> {//直接写方法体即可System.out.println("Runnable running");System.out.println("Hello Thread");};//将Runnable对象传给ThreadThread t = new Thread(r);//启动线程t.start();}
}

可以在Runnable上使用Alt+Enter

原理之 Thread 与 Runnable 的关系

分析 Thread 的源码，理清它与 Runnable 的关系

Thread源码：

Thread的init( )方法：

Thread的run( )方法：

如果没有传入Runnable对象，自然不会有target，所以用方法一直接使用Thread创建线程时，需要重写run( )方法。

小结

方法1 是把线程和任务合并在了一起
方法2 是把线程和任务分开了
用 Runnable 更容易与线程池等高级 API 配合
用 Runnable 让任务类脱离了 Thread 继承体系，更灵活

方法三：使用FutureTask与Thread结合

使用FutureTask可以用泛型指定线程的返回值类型（Runnable的run方法没有返回值）

public class Test3 {public static void main(String[] args) throws ExecutionException, InterruptedException {//需要传入一个Callable对象FutureTask<Integer> task = new FutureTask<Integer>(new Callable<Integer>() {@Overridepublic Integer call() throws Exception {System.out.println("线程执行!");Thread.sleep(1000);return 100;}});Thread r1 = new Thread(task, "t2");r1.start();//获取线程中方法执行后的返回结果，相当于阻塞在这等待结果的返回System.out.println(task.get());}}

或者

public class UseFutureTask {public static void main(String[] args) throws ExecutionException, InterruptedException {FutureTask<String> futureTask = new FutureTask<>(new MyCall());Thread thread = new Thread(futureTask);thread.start();// 获得线程运行后的返回值，如果线程还没执行完，需要阻塞等待线程执行完后的返回结果System.out.println(futureTask.get());}}class MyCall implements Callable<String> {@Overridepublic String call() throws Exception {return "hello world";}}

Callable的call( )方法有返回值，且可以抛出异常；Runnable的没有返回值。

Callable接口源码：

FutureTask源码：

2、原理之线程运行

栈与栈帧

Java Virtual Machine Stacks （Java 虚拟机栈）我们都知道 JVM 中由堆、栈、方法区所组成，其中栈内存是给谁用的呢？

其实就是线程，每个线程启动后，虚拟机就会为其分配一块栈内存
每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存
每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

代码示例

public class TestFrames {public static void main(String[] args) {method1(10);}private static void method1(int x) {int y = x + 1;Object m = method2();System.out.println(m);}private static Object method2() {Object n = new Object();return n;}
}

程序计数器告诉cpu该执行那一行代码
对象的创建都会放在堆中（new Object等）
当执行到方法的调用时，会产生新的栈帧，操作新的局部变量（Object m = method2()等）
当方法执行完后，释放内存，销毁栈帧，回到上一个栈帧

多线程的栈帧

多线程运行，栈帧是线程私有的，栈帧内存互不干扰，可能t1线程执行到了method1，main线程已经执行到了method2。

线程上下文切换（Thread Context Switch）

因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码

线程的 cpu 时间片用完
垃圾回收有更高优先级的线程需要运行
线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

当 Context Switch 发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java 中对应的概念就是程序计数器（Program Counter Register），它的作用是记住下一条 jvm 指令的执行地址，是线程私有的

状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等
Context Switch 频繁发生会影响性能

3、常用方法

方法名	static	功能说明	注意
start( )		启动一个新线程，在新的线程运行 run 方法中的代码	start 方法只是让线程进入就绪，里面代码不一定立刻运行（CPU 的时间片还没分给它）。每个线程对象的 start方法只能调用一次，如果调用了多次会出现 IllegalThreadStateException
run( )		新线程启动后会调用的方法	如果在构造 Thread 对象时传递了 Runnable 参数，则线程启动后会调用 Runnable 中的 run 方法，否则默认不执行任何操作。但可以创建 Thread 的子类对象，来覆盖默认行为
join( )		等待线程运行结束
join(long n)		等待线程运行结束,最多等待 n 毫秒
getId( )		获取线程长整型的 id	id 唯一
getName( )		获取线程名
setName(String)		修改线程名
getPriority( )		获取线程优先级
setPriority(int)		修改线程优先级	java中规定线程优先级是1~10 的整数，较大的优先级能提高该线程被 CPU 调度的机率
getState( )		获取线程状态	Java 中线程状态是用 6 个 enum 表示，分别为： NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED
isInterrupted( )		判断是否被打断，	不会清除打断标记
isAlive( )		线程是否存活（还没有运行完毕）
interrupt( )		打断线程	如果被打断线程正在 sleep，wait，join 会导致被打断的线程抛出 InterruptedException，并清除打断标记；如果打断的正在运行的线程，则会设置打断标记；park 的线程被打断，也会设置打断标记
interrupted( )	static	判断当前线程是否被打断	会清除打断标记
currentThread( )	static	获取当前正在执行的线程
sleep(long n)	static	让当前执行的线程休眠n毫秒，休眠时让出 cpu 的时间片给其它线程
yield( )	static	提示线程调度器让出当前线程对 CPU的使用	主要是为了测试和调试

start( ) 与 run( )

调用start

public static void main(String[] args) {Thread thread = new Thread(){@Overridepublic void run(){log.debug("我是一个新建的线程正在运行中");FileReader.read(fileName);}};thread.setName("新建线程");thread.start();log.debug("主线程");}

程序运行结果：程序在 t1 线程运行， FileReader.read() 方法调用是异步的

11:59:40.711 [main] DEBUG com.concurrent.test.Test4 - 主线程
11:59:40.711 [新建线程] DEBUG com.concurrent.test.Test4 - 我是一个新建的线程正在运行中
11:59:40.732 [新建线程] DEBUG com.concurrent.test.FileReader - read [test] start ...
11:59:40.735 [新建线程] DEBUG com.concurrent.test.FileReader - read [test] end ... cost: 3 ms

调用run

public static void main(String[] args) {Thread thread = new Thread(){@Overridepublic void run(){log.debug("我是一个新建的线程正在运行中");FileReader.read(fileName);}};thread.setName("新建线程");thread.run();log.debug("主线程");}

程序运行结果：程序仍在 main 线程运行， FileReader.read() 方法调用还是同步的

12:03:46.711 [main] DEBUG com.concurrent.test.Test4 - 我是一个新建的线程正在运行中
12:03:46.727 [main] DEBUG com.concurrent.test.FileReader - read [test] start ...
12:03:46.729 [main] DEBUG com.concurrent.test.FileReader - read [test] end ... cost: 2 ms
12:03:46.730 [main] DEBUG com.concurrent.test.Test4 - 主线程

小结

直接调用 run() 是在主线程中执行了 run()，没有启动新的线程
使用 start() 是启动新的线程，通过新的线程间接执行 run()方法中的代码
被创建的Thread对象直接调用重写的run方法时， run方法是在主线程中被执行的，而不是在我们所创建的线程中执行。
所以如果想要在所创建的线程中执行run方法，需要使用Thread对象的start方法。

sleep( ) 与 yield( )

sleep (使线程阻塞)

调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞），可通过state( )方法查看

public static void main(String[] args) {Thread t1 = new Thread("t1") {@Overridepublic void run() {try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}};t1.start();log.debug("t1 state: {}", t1.getState());try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}log.debug("t1 state: {}", t1.getState());}

程序运行结果

20:40:26.349 c.Test6 [main] - t1 state: RUNNABLE
20:40:26.865 c.Test6 [main] - t1 state: 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); // 让主线程睡眠1秒log.debug("interrupt...");t1.interrupt();}

睡眠结束后的线程未必会立刻得到执行
建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性。如：

//休眠一秒
TimeUnit.SECONDS.sleep(1);
//休眠一分钟
TimeUnit.MINUTES.sleep(1);

yield （让出当前线程）

让出，谦让的意思，让出 CPU 使用权

调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态（仍然有可能被执行），然后调度执行其它线程
具体的实现依赖于操作系统的任务调度器

sleep 和 yield区别

任务调度器会把时间片分配给就绪状态的线程
任务调度器不会把时间片分配给阻塞状态的线程

线程优先级

线程优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它
如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用

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();}

yield 和线程优先级都仅仅对调度器是一个提示而已，不能真正控制。

应用 - sleep防止cpu占用100%

在没有利用 cpu 来计算时，不要让 while(true) 空转浪费 cpu，这时可以使用 yield 或 sleep 来让出 cpu 的使用权给其他程序

while(true) {try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}
}

可以用 wait 或条件变量达到类似的效果
不同的是，后两种都需要加锁，并且需要相应的唤醒操作，一般适用于要进行同步的场景
sleep 适用于无需锁同步的场景

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 行不行？为什么？
- 不太好，因为你不知道t1线程从一开始到结束到底需要花费多长时间
用 join，加在 t1.start( ) 之后即可
- 让主线程阻塞，等待t1线程完成

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(); t1.join(); // 等待线程1的结束log.debug("结果为:{}", r); log.debug("结束");
}

应用之同步（案例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 呢？

有时效的 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(2);r1 = 10;});long start = System.currentTimeMillis(); t1.start();// 线程执行结束会导致 join 结束 log.debug("join begin");t1.join(1500); long end = System.currentTimeMillis(); log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
}

等够时间

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 结束 log.debug("join begin");t1.join(3000); long end = System.currentTimeMillis(); log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
}

interrupt 方法详解

用于打断阻塞(sleep wait join…)的线程。处于阻塞状态的线程，CPU不会给其分配时间片。

如果一个线程在在运行中被打断，打断标记会被置为true。
如果是打断因sleep wait join方法而被阻塞的线程，会将打断标记置为false

//用于查看打断标记，返回值为boolean类型
t1.isInterrupted();

打断 sleep，wait，join 的线程

打断 sleep 的线程, 会清空打断状态，以 sleep 为例

public class Test11 {public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {log.debug("sleep...");try {Thread.sleep(5000); // wait, join} catch (InterruptedException e) {e.printStackTrace();}},"t1");t1.start();Thread.sleep(1000);log.debug("interrupt");t1.interrupt();log.debug("打断标记:{}", t1.isInterrupted());}
}

打断正常运行的线程

打断正常运行的线程, 不会清空打断状态

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

interrupt方法的应用——两阶段终止模式

当我们在执行线程一时，想要终止线程二，这是就需要使用interrupt方法来优雅的停止线程二。

/*** @author xiexu* @create 2022-01-27 2:16 下午*/
public class Test4 {public static void main(String[] args) throws InterruptedException {TwoPhaseTermination tpt = new TwoPhaseTermination();tpt.start();Thread.sleep(3500);tpt.stop();}}class TwoPhaseTermination {private Thread monitor;/*** 启动监控器线程*/public void start() {//设置线控器线程，用于监控线程状态monitor = new Thread() {@Overridepublic void run() {//开始不停的监控while (true) {//判断当前线程是否被打断了if (Thread.currentThread().isInterrupted()) {System.out.println("料理后事");//终止线程执行break;}try {//线程休眠Thread.sleep(1000); //情况1System.out.println("执行监控记录..."); //情况2} catch (InterruptedException e) {e.printStackTrace();//如果是在sleep(休眠)的时候被打断，不会将打断标记设置为true，这时要重新设置打断标记Thread.currentThread().interrupt();}}}};monitor.start();}/*** 用于停止监控器线程*/public void stop() {//打断线程monitor.interrupt();}
}

程序运行结果：

执行监控记录...
执行监控记录...
执行监控记录...
java.lang.InterruptedException: sleep interruptedat java.lang.Thread.sleep(Native Method)at cn.xx.java.TwoPhaseTermination$1.run(Test4.java:40)
料理后事

打断 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(1);t1.interrupt();}

如果打断标记已经是 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();
}

可以使用 Thread.interrupted() 清除打断状态

如果park生效，会停在第二个park。因为第一次调用LockSupport.park( );程序会停住，但是由于调用了Thread.interrupted( )，清除了打断标记，在返回当前线程的打断标记后，会重新把打断标记置为false，如下例

private static void test4() {Thread t1 = new Thread(() -> {for (int i = 0; i < 5; i++) {log.debug("park...");LockSupport.park();log.debug("打断状态：{}", Thread.interrupted());}});t1.start();sleep(1);t1.interrupt();
}

不推荐使用的打断方法

还有一些不推荐使用的方法，这些方法已过时，容易破坏同步代码块，造成线程死锁

方法名	功能说明	替代方法
stop( )	停止线程运行	两阶段模式终止
suspend( )	挂起（暂停）线程运行	wait( )
resume( )	恢复线程运行	notify( )

主线程与守护线程

默认情况下，Java 进程需要等待所有线程都运行结束，才会结束。有一种特殊的线程叫做守护线程，只要其它非守护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。

public class Test15 {public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {while (true) {if (Thread.currentThread().isInterrupted()) {break;}}log.debug("结束");}, "t1");t1.setDaemon(true); //把t1设置为守护线程t1.start();Thread.sleep(1000);log.debug("结束");}
}

注意

垃圾回收器线程就是一种守护线程

Tomcat 中的 Acceptor 和 Poller 线程都是守护线程，所以 Tomcat 接收到 shutdown 命令后，不会等待它们处理完当前请求

4、五种状态

这是从 操作系统 层面来描述的

【初始状态】仅是在语言层面创建了线程对象，还未与操作系统线程关联
【可运行状态】（就绪状态）指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行
【运行状态】指获取了 CPU 时间片运行中的状态
- 当 CPU 时间片用完，会从【运行状态】转换至【可运行状态】，会导致线程的上下文切换
【阻塞状态】
- 如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU，会导致线程上下文切换，进入【阻塞状态】
- 等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】
- 与【可运行状态】的区别是，对【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑调度它们
【终止状态】表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态

5、六种状态

这是从 Java API 层面来描述的

根据 Thread.State 枚举，分为六种状态

NEW 线程刚被创建，但是还没有调用 start( ) 方法
RUNNABLE 当调用了 start( ) 方法之后，注意，Java API 层面的 RUNNABLE 状态涵盖了操作系统层面的【可运行状态】、【运行状态】和【阻塞状态】（由于 BIO 导致的线程阻塞，在 Java 里无法区分，仍然认为是可运行）。对应着的状态为，可能分到时间片、可能没有分配到时间片，或者操作系统IO时的阻塞状态。
BLOCKED ， WAITING ， TIMED_WAITING 都是 Java API 层面对【阻塞状态】的细分，后面会在状态转换一节详述
TERMINATED 当线程代码运行结束

@Slf4j(topic = "c.TestState")
public class TestState {public static void main(String[] args) throws IOException {Thread t1 = new Thread("t1") {@Overridepublic void run() {log.debug("running...");}};Thread t2 = new Thread("t2") {@Overridepublic void run() {while(true) { // runnable}}};t2.start();Thread t3 = new Thread("t3") {@Overridepublic void run() {log.debug("running...");}};t3.start();Thread t4 = new Thread("t4") {@Overridepublic void run() {synchronized (TestState.class) {try {Thread.sleep(1000000); // timed_waiting} catch (InterruptedException e) {e.printStackTrace();}}}};t4.start();Thread t5 = new Thread("t5") {@Overridepublic void run() {try {t2.join(); // waiting} catch (InterruptedException e) {e.printStackTrace();}}};t5.start();Thread t6 = new Thread("t6") {@Overridepublic void run() {synchronized (TestState.class) { // blocked// t4线程先把锁拿到了，t6拿不到锁，一直等着拿锁try {Thread.sleep(1000000);} catch (InterruptedException e) {e.printStackTrace();}}}};t6.start();try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}log.debug("t1 state {}", t1.getState());log.debug("t2 state {}", t2.getState());log.debug("t3 state {}", t3.getState());log.debug("t4 state {}", t4.getState());log.debug("t5 state {}", t5.getState());log.debug("t6 state {}", t6.getState());System.in.read();}
}

t1声明了但是没有start
t2 start了，但是while(true)一直运行
t3 正常结束
t4 sleep了，等待睡醒
t5 被join了，必须等别人执行完才能接着运行
t6 想要锁，但没有锁，等着别人释放锁

6、习题

阅读华罗庚《统筹方法》，给出烧水泡茶的多线程解决方案，提示

参考图二，用两个线程（两个人协作）模拟烧水泡茶过程
- 文中办法乙、丙都相当于任务串行
- 而图一相当于启动了 4 个线程，有点浪费
用 sleep(n) 模拟洗茶壶、洗水壶等耗费的时间

附：华罗庚《统筹方法》

统筹方法，是一种安排工作进程的数学方法。它的实用范围极广泛，在企业管理和基本建设中，以及关系复杂的科研项目的组织与管理中，都可以应用。

怎样应用呢？主要是把工序安排好。

比如，想泡壶茶喝。当时的情况是：开水没有；水壶要洗，茶壶、茶杯要洗；火已生了，茶叶也有了。怎么办？

办法甲：洗好水壶，灌上凉水，放在火上；在等待水开的时间里，洗茶壶、洗茶杯、拿茶叶；等水开了，泡茶喝。
办法乙：先做好一些准备工作，洗水壶，洗茶壶茶杯，拿茶叶；一切就绪，灌水烧水；坐待水开了，泡茶喝。
办法丙：洗净水壶，灌上凉水，放在火上，坐待水开；水开了之后，急急忙忙找茶叶，洗茶壶茶杯，泡茶喝。

哪一种办法省时间？我们能一眼看出，第一种办法好，后两种办法都窝了工。

这是小事，但这是引子，可以引出生产管理等方面有用的方法来。

水壶不洗，不能烧开水，因而洗水壶是烧开水的前提。没开水、没茶叶、不洗茶壶茶杯，就不能泡茶，因而这些又是泡茶的前提。它们的相互关系，可以用下边的箭头图来表示：

从这个图上可以一眼看出，办法甲总共要16分钟（而办法乙、丙需要20分钟）。如果要缩短工时、提高工作效率，应当主要抓烧开水这个环节，而不是抓拿茶叶等环节。同时，洗茶壶茶杯、拿茶叶总共不过4分钟，大可利用“等水开”的时间来做。

是的，这好像是废话，卑之无甚高论。有如走路要用两条腿走，吃饭要一口一口吃，这些道理谁都懂得。但稍有变化，临事而迷的情况，常常是存在的。在近代工业的错综复杂的工艺过程中，往往就不是像泡茶喝这么简单了。任务多了，几百几千，甚至有好几万个任务。关系多了，错综复杂，千头万绪，往往出现“万事俱备，只欠东风”的情况。由于一两个零件没完成，耽误了一台复杂机器的出厂时间。或往往因为抓的不是关键，连夜三班，急急忙忙，完成这一环节之后，还得等待旁的环节才能装配。

洗茶壶，洗茶杯，拿茶叶，或先或后，关系不大，而且同是一个人的活儿，因而可以合并成为：

看来这是“小题大做”，但在工作环节太多的时候，这样做就非常必要了。

这里讲的主要是时间方面的事，但在具体生产实践中，还有其他方面的许多事。这种方法虽然不一定能直接解决所有问题，但是，我们利用这种方法来考虑问题，也是不无裨益的。

应用之统筹（烧水泡茶）

@Slf4j(topic = "c.Test16")
public class Test16 {public static void main(String[] args) {Thread t1 = new Thread(() -> {log.debug("洗水壶");sleep(1);log.debug("烧开水");sleep(5);},"老王");Thread t2 = new Thread(() -> {log.debug("洗茶壶");sleep(1);log.debug("洗茶杯");sleep(2);log.debug("拿茶叶");sleep(1);try {t1.join(); //t2等待t1执行完成再执行后面的任务} catch (InterruptedException e) {e.printStackTrace();}log.debug("泡茶");},"小王");t1.start();t2.start();}
}

上面模拟的是小王等老王的水烧开了，小王泡茶，如果反过来要实现老王等小王的茶叶拿来了，老王泡茶呢？代码最好能适应两种情况
上面的两个线程其实是各执行各的，如果要模拟老王把水壶交给小王泡茶，或模拟小王把茶叶交给老王泡茶呢

本章小结

本章的重点在于掌握

线程创建
线程重要 api，如 start，run，sleep，join，interrupt 等
线程状态
应用方面
- 异步调用：主线程执行期间，其它线程异步执行耗时操作
- 提高效率：并行计算，缩短运算时间
- 同步等待：join
- 统筹规划：合理使用线程，得到最优效果
原理方面
- 线程运行流程：栈、栈帧、上下文切换、程序计数器
- Thread 两种创建方式的源码
模式方面
- 终止模式之两阶段终止