第二章 - 线程的创建

lewis 1年前 (2024-04-10) 阅读数 9 #技术

第二章 - 线程的创建文章目录第二章 - 线程的创建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）等待多个结果有时效的 joininterrupt 方法详解打断 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、常用方法

方法名

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

不推荐使用的打断方法

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

方法名

static

功能说明

替代方法

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") {
            @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声明了但是没有startt2 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 两种创建方式的源码模式方面终止模式之两阶段终止

版权声明

本文仅代表作者观点，不代表博信信息网立场。

上一篇：3台三菱PLC之间如何快速搭建简单cpu无线通讯？(多台三菱plc的485通讯) 下一篇：linux中证书验证失败Certificate verification failed

第二章 - 线程的创建

版权声明

作者文章