第二章 - 线程的创建

第二章 - 线程的创建

文章目录

• ​​第二章 - 线程的创建​​
• ​​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 {
    @Override
    public 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() {
      @Override
      public void run() {
        System.out.println("Runnable running");
      }
    };
    //将Runnable对象传给Thread
    Thread t = new Thread(r);
    //启动线程
    t.start();
  }
}

或者

public class CreateThread2 {
   private static class MyRunnable implements Runnable {

      @Override
      public 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对象传给Thread
    Thread 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>() {
      @Override
      public 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> {

   @Override
   public 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、常用方法

start( ) 与 run( )

调用start

public static void main(String[] args) {
        Thread thread = new Thread(){
          @Override
          public 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

调用run

public static void main(String[] args) {
        Thread thread = new Thread(){
          @Override
          public 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") {
            @Override
            public 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:

• 其它线程可以使用interrupt方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException

public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread("t1") {
            @Override
            public 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() {
            @Override
            public void run() {
                //开始不停的监控
                while (true) {
                    //判断当前线程是否被打断了
                    if (Thread.currentThread().isInterrupted()) {
                        System.out.println("料理后事");
                        //终止线程执行
                        break;
                    }
                    try {
                        //线程休眠
                        Thread.sleep(1000); //情况1
                        System.out.println("执行监控记录..."); //情况2
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        //如果是在sleep(休眠)的时候被打断，不会将打断标记设置为true，这时要重新设置打断标记
                        Thread.currentThread().interrupt();
                    }
                }
            }
        };
        monitor.start();
    }

    /**
     * 用于停止监控器线程
     */
    public void stop() {
        //打断线程
        monitor.interrupt();
    }
}

程序运行结果：

执行监控记录...
执行监控记录...
执行监控记录...
java.lang.InterruptedException: sleep interrupted
  at 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();
}

不推荐使用的打断方法

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

主线程与守护线程

默认情况下，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") {
            @Override
            public void run() {
                log.debug("running...");
            }
        };

        Thread t2 = new Thread("t2") {
            @Override
            public void run() {
                while(true) { // runnable

                }
            }
        };
        t2.start();

        Thread t3 = new Thread("t3") {
            @Override
            public void run() {
                log.debug("running...");
            }
        };
        t3.start();

        Thread t4 = new Thread("t4") {
            @Override
            public void run() {
                synchronized (TestState.class) {
                    try {
                        Thread.sleep(1000000); // timed_waiting
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t4.start();

        Thread t5 = new Thread("t5") {
            @Override
            public void run() {
                try {
                    t2.join(); // waiting
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        t5.start();

        Thread t6 = new Thread("t6") {
            @Override
            public 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 两种创建方式 的源码

• 模式方面

• 终止模式之两阶段终止