[Java知识库]《JUC并发编程 - 高级篇》进程与线程概述 | Java线程（创建线程、查看线程、线程常见方法、线程状态）

📒博客首页：热爱编程的大李子 📒

🌞文章目的：程与线程概述 | Java线程（创建线程、查看线程、线程常见方法、线程状态）🌞

🍄参考视频：深入学习Java并发编程🍄

🙏博主在学习阶段，如若发现问题，请告知，非常感谢🙏

💙同时也非常感谢各位小伙伴们的支持💙

🌈每日一语：未经一番寒彻骨，哪得梅花扑鼻香！🌈

💗感谢： 我只是站在巨人们的肩膀上整理本篇文章，感谢走在前路的大佬们💗

🌟最后，祝大家每天进步亿点点！ 欢迎大家点赞👍?收藏???评论💬支持博主🤞！🌟

一、进程和线程

1.1 进程和线程

进程

• 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的
• 当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。
• 进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程（例如记事本、画图、浏览器
  等），也有的程序只能启动一个实例进程（例如网易云音乐、360 安全卫士等）

线程

• 一个进程之内可以分为一到多个线程。

• 一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给 CPU 执行

• Java 中，线程作为最小调度单位，进程作为资源分配的最小单位。 在 windows 中进程是不活动的，只是作为线程的容器

简单对比：进程只用做线程的容器,用来加载指令,管理内存和IO, 是静态的。线程将指令按照一定顺序交给CPU执行 ,是和CPU交互的,是动态的。

二者对比

• 进程基本上相互独立的，而线程存在于进程内，是进程的一个子集
• 进程拥有共享的资源，如内存空间等，供其内部的线程共享
• 进程间通信较为复杂
  • 同一台计算机的进程通信称为 IPC（Inter-process communication）
  • 不同计算机之间的进程通信，需要通过网络，并遵守共同的协议，例如 HTTP
• 线程通信相对简单，因为它们共享进程内的内存，一个例子是多个线程可以访问同一个共享变量
• 线程更轻量，线程上下文切换成本一般上要比进程上下文切换低

上下文切换:当一个任务不运行时候,其他任务要运行.内存此时不够了,怎么办, 先把那些用不到的线程暂停(将其代码存储起来)，之后等内存空闲了继续运行。进程包含多个线程，所以进程上下文切换到耗费比较高!

1.2 并行与并发

单核 cpu 下，线程实际还是 串行执行 的。操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 cpu 在线程间（时间片很短）的切换非常快，人类感觉是 同时运行的 。总结为一句话就是： 微观串行，宏观并行。
一般会将这种 线程轮流使用 CPU 的做法称为并发， concurrent

多核 cpu下，每个 核（core） 都可以调度运行线程，这时候线程可以是并行的。

引用 Rob Pike 的一段描述：

• 并发（concurrent）是同一时间应对（dealing with）多件事情的能力
• 并行（parallel）是同一时间动手做（doing）多件事情的能力

例子

• 家庭主妇做饭、打扫卫生、给孩子喂奶，她一个人轮流交替做这多件事，这时就是并发

• 家庭主妇雇了个保姆，她们一起这些事，这时既有并发，也有并行（这时会产生竞争，例如锅只有一口，一个人用锅时，另一个人就得等待）。

• 雇了3个保姆，一个专做饭、一个专打扫卫生、一个专喂奶，互不干扰，这时是并行

• 应用之异步调用（案例1）

1.3 应用

1.3.1 同步调用和异步调用

以调用方角度来讲，如果

• 需要等待结果返回，才能继续运行就是同步

• 不需要等待结果返回，就能继续运行就是异步

1) 设计
多线程可以让方法执行变为异步的（即不要巴巴干等着）比如说读取磁盘文件时，假设读取操作花费了 5 秒钟，如果没有线程调度机制，这 5 秒 cpu 什么都做不了，其它代码都得暂停…

2) 代码演示

/**
 * 同步等待
 */
@Slf4j(topic = "c.Sync")
public class Sync {

    public static void main(String[] args) {
        FileReader.read(Constants.MP4_FULL_PATH);
        log.debug("do other things ...");
    }

}

/**
 * 异步
 */

@Slf4j(topic = "c.Async")
public class Async {

    public static void main(String[] args) {
        new Thread(() -> FileReader.read(Constants.MP4_FULL_PATH)).start();
        log.debug("do other things ...");
    }
}

3) 结论

• 比如在项目中，视频文件需要转换格式等操作比较费时，这时开一个新线程处理视频转换，避免阻塞主线程。 （比如爱奇艺中下载视频,就会重新开启一个线程）
• tomcat 的异步 servlet 也是类似的目的，让用户线程处理耗时较长的操作，避免阻塞 tomcat 的工作线程
• ui 程序中，开线程进行其他操作，避免阻塞 ui 线程

1.3.2 多线程应用之提高效率

充分利用多核 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 才能提高效率，单核仍然时是轮流执行

1) 代码演示 （此部分只需要理解就OK）

package com.itcast;

import org.openjdk.jmh.annotations.*;

import java.util.Arrays;
import java.util.concurrent.FutureTask;

/**
 * 案例：对一亿个数进行求和运算，比较单核和多核下的多线程效率
 */

@Fork(1)
@BenchmarkMode(Mode.AverageTime)  //程序平均执行时间
@Warmup(iterations=3)  //热身次数
@Measurement(iterations=5) //进行无论测试
public class MyBenchmark {
    static int[] ARRAY = new int[1000_000_00];
    static {
        Arrays.fill(ARRAY, 1);
    }
    //建立 四个线程，每个计算250 000 00个数，然后将结果汇总返回。
    @Benchmark
    public int c() throws Exception {
        int[] array = ARRAY;
        FutureTask<Integer> t1 = new FutureTask<>(()->{
            int sum = 0;
            for(int i = 0; i < 250_000_00;i++) {
                sum += array[0+i];
            }
            return sum;
        });
        FutureTask<Integer> t2 = new FutureTask<>(()->{
            int sum = 0;
            for(int i = 0; i < 250_000_00;i++) {
                sum += array[250_000_00+i];
            }
            return sum;
        });
        FutureTask<Integer> t3 = new FutureTask<>(()->{
            int sum = 0;
            for(int i = 0; i < 250_000_00;i++) {
                sum += array[500_000_00+i];
            }
            return sum;
        });
        FutureTask<Integer> t4 = new FutureTask<>(()->{
            int sum = 0;
            for(int i = 0; i < 250_000_00;i++) {
                sum += array[750_000_00+i];
            }
            return sum;
        });
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
        new Thread(t4).start();
        return t1.get() + t2.get() + t3.get()+ t4.get();
    }

    //单个线程计算1亿个数
    @Benchmark
    public int d() throws Exception {
        int[] array = ARRAY;
        FutureTask<Integer> t1 = new FutureTask<>(()->{
            int sum = 0;
            for(int i = 0; i < 1000_000_00;i++) {
                sum += array[0+i];
            }
            return sum;
        });
        new Thread(t1).start();
        return t1.get();
    }
}

运行结果：

2) 结论

1. 单核 cpu 下，多线程不能实际提高程序运行效率，只是为了能够在不同的任务之间切换，不同线程轮流使用cpu ，不至于一个线程总占用 cpu，别的线程没法干活
2. 多核 cpu 可以并行跑多个线程，但能否提高程序运行效率还是要分情况的

• 有些任务，经过精心设计，将任务拆分，并行执行，当然可以提高程序的运行效率。但不是所有计算任
  务都能拆分（参考后文的【阿姆达尔定律】）
• 也不是所有任务都需要拆分，任务的目的如果不同，谈拆分和效率没啥意义

3. IO 操作不占用 cpu，只是我们一般拷贝文件使用的是【阻塞 IO】，这时相当于线程虽然不用 cpu，但需要一直等待 IO 结束，没能充分利用线程。所以才有后面的==【非阻塞 IO】和【异步 IO】==优化

二、Java线程

2.1 创建和运行线程

2.1.1 方法一：直接使用 Thread

/**
 * @author lxy
 * @version 1.0
 * @Description 方法一：使用Thread创建线程（任务和线程绑定在一起）
 * @date 2022/5/22 18:52
 */
@Slf4j(topic = "c.Test1")
public class Test1 {
    public static void test01(String[] args) {
        Thread t = new Thread(){ //使用匿名内部类的方式.
            @Override
            public void run() {//run方法里面写线程要执行的任务。。
                log.debug("running");
            }
        };
        t.setName("t1");
        t.start();
        log.debug("running");
    }
}

2.1.2 方法二：使用 Runnable 配合 Thread

把【线程】和【任务】（要执行的代码）分开

• Thread 代表线程
• Runnable 可运行的任务（线程要执行的代码）

/**
 * @author lxy
 * @version 1.0
 * @Description 方法二：使用Runnable创建线程（任务和线程分离，推荐使用）
 * @date 2022/5/22 18:52
 */
@Slf4j(topic = "c.Test2")
public class Test2 {
    public void test01() {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                log.debug("running");
            }
        };

        Thread t = new Thread(r, "t2");

        t.start();

        log.debug("running");

    }

    //使用Lambda表达式简化
    public void test02(){
        Runnable r = ()-> {log.debug("running");};//使用Lambda表达式简化

        Thread t = new Thread(r, "t2");

        t.start();

        log.debug("running");
    }
}

2.1.3 原理之 Thread 与 Runnable 的关系

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

/**
 * @author lxy
 * @version 1.0
 * @Description 面试题：你执行的是run方法是Thread类的还是Runnable接口的？
 * @date 2022/5/26 18:35
 */
public class ThreadTests {

    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"：runnable's run method");
            }
        };

        Thread thread1 = new Thread(runnable,"thread1");

        Thread thread2 = new Thread("thread2"){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"：sub Thread class's run method");
            }
        };

        Thread thread3 = new Thread(runnable,"thread3"){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"：sub Thread class's run method");
            }
        };

        Thread thread4 = new Thread(runnable,"thread4"){
            @Override
            public void run() {
                super.run();
                System.out.println(Thread.currentThread().getName()+"：sub Thread class's run method");
            }
        };

        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}

• thread1是由调用的有参构造方法，那么执行链应该是Thread.run调用Runnable的run方法，不出意外的话打印结果应该就是thread1：runnable's run method
• thread2 是创建了一个thread子类对象，并且覆盖了Thread类的run方法，那么最终执行的是子类的run方法，结果应该是thread2：sub Thread's run method
• thread3 创建了和thread2 同样的类对象，但是确调用了父类的有参构造方法，也就是初始化了Runnable类型的target对象，虽然有了target，但是由于我们重写了run方法，那么就应该执行子类的方法，结果应该是thread3：sub Thread class's run method
• thread4 创建方式和thread3是一样的，但是run方法内部又调用了父类Thread的方法，就是说会先执行Thread类的run方法，再执行我们子类的打印内容，最终结果应该有两行，分别是thread4：runnable's run method thread4：sub Thread class's run method

小结

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

2.1.4 方法三：FutureTask 配合 Thread

FutureTask 能够接收 Callable 类型的参数，用来处理有返回结果的情况

/**
 * @author lxy
 * @version 1.0
 * @Description  使用FutureTask创建Thread
 * @date 2022/5/26 22:08
 */
@Slf4j(topic = "c.Test3")
public class Test3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> task = new FutureTask <>(new Callable <Integer>() {
            @Override
            public Integer call() throws Exception {
                log.debug("running");
                Thread.sleep(2000);
                return 100;
            }
        });

        Thread t1 = new Thread(task, "t1");
        t1.start();
        log.debug("{}",task.get());

    }
}

2.2 观察多个线程同时运行

特点

• 交替执行
• 谁先谁后，不由我们控制

@Slf4j(topic = "c.Test3")
public class Test3 {
    public static void main(String[] args) {
        new Thread(() -> {
            while(true) {
                log.debug("running...");
            }
        }, "t1").start();

        new Thread(() -> {
            while(true) {
                log.debug("running...");
            }
        }, "t2").start();
    }
}

2.3 查看进程线程的方法

windows

• 任务管理器可以查看进程和线程数，也可以用来杀死进程
• tasklist 查看进程
• taskkill 杀死进程

linux

• ps -ef 查看所有进程
• ps -ef -p 查看某个进程（PID）的所有线程
• kill 杀死进程
• top 按大写 H 切换是否显示线程
• top -H -p 查看某个进程（PID）的所有线程

环境准备：

ps+kill

top

Java

• jps 命令查看所有 Java 进程
• jstack 查看某个 Java 进程（PID）的所有线程状态
• jconsole 来查看某个 Java 进程中线程的运行情况（图形界面）

jstack

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类

cmd下通过jconsole启动该工具,并通过IP+端口号进行连接

如果要认证访问，还需要做如下步骤

• 复制 jmxremote.password 文件
• 修改 jmxremote.password 和 jmxremote.access 文件的权限为 600 即文件所有者可读写
• 连接时填入 controlRole（用户名），R&D（密码）

2.4 原理之线程运行

栈与栈帧

Java Virtual Machine Stacks （Java 虚拟机栈）
我们都知道 JVM 中由堆、栈、方法区所组成，其中栈内存是给谁用的呢？其实就是线程，每个线程启动后，虚拟机就会为其分配一块栈内存。

• 每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存
• 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

一个线程对应一个虚拟机栈，一个栈帧（局部变量表 操作数栈 动态链接 返回地址）对应一个方法

线程上下文切换（Thread Context Switch）
因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码

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

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

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

2.5 常见方法

2.6 start 与 run

调用 run

@Slf4j(topic = "c.Test4")
public class Test4 {
    public static void main(String[] args) {
        Thread t1 = new Thread("t1"){
            @Override
            public void run() {
                log.debug("running...");
                FileReader.read(Constants.MP4_FULL_PATH);
            }
        };

        t1.run();

        log.debug("do other things...");

    }
}

运行结果

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

调用 start

将上述代码的 t1.run() 改为t1.start(); 运行之。

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

小结

• 直接调用 run 是在主线程中执行了 run，没有启动新的线程
• 使用 start 是启动新的线程，通过新的线程间接执行 run 中的代码

2.7 sleep与yield

2.7.1 sleep

1. 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）

@Slf4j(topic = "c.Test5")
public class Test5 {
    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());

    }
}

运行结果

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

@Slf4j(topic = "c.Test7")
public class Test7 {
    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(500);
       log.debug("interrupt...");
       t1.interrupt();
    }
}

运行结果：

3. 睡眠结束后的线程未必会立刻得到执行 （此时CPU可能正在执行其他线程，必须等待任务调度器为 t1分配时间片后才可执行）
4. 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

TimeUnit.SECONDS.sleep(10);//休眠10s

底层分析：

2.7.2 yield

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

对比 yield与sleep

相同点：两者都是让当前线程不再执行，调度执行其他线程

不同点：

• 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）。 此时当前线程不会被执行，直至达到sleep的时间或线程被唤醒；调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程,此时线程也就可能被再次调用，这依赖于任务调度器。
• sleep（）可以有时间参数，yield（）中没有时间参数。

2.7.3 线程优先级

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

关于yield和优先级的对比

@Slf4j(topic = "c.Test9")
public class Test9 {

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

2.7.4 sleep和yield使用案例

使用sleep和yield可以防止CPU占用达到 100 %

2.8 join 方法详解

2.8.1 为什么需要 join

下面的代码执行，打印 r 是什么？

@Slf4j(topic = "c.Test10")
public class Test10 {
    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");
        t1.start();
        log.debug("结果为:{}", r);
        log.debug("结束");
    }
}

打印结果为：0。

分析

• 因为主线程和线程 t1 是并行执行的，t1 线程需要 1 秒之后才能算出 r=10

• 而主线程一开始就要打印 r 的结果，所以只能打印出 r=0

• 一句话：因为异步性，后面的程序可能先执行，因此当进程睡觉的时候，就把r=0输出了 因此结果为0

解决方法

• 用 sleep 行不行？为什么？ 可行，但是main线程需要和t1线程 sleep相同的时间。不推荐使用
• 用 join，加在 t1.start() 之后即可

2.8.2 应用之同步（案例1）

以调用方角度来讲，如果

• 需要等待结果返回，才能继续运行就是同步
• 不需要等待结果返回，就能继续运行就是异步

2.8.3 应用之同步（等待多个结果）

问，下面代码 cost 大约多少秒？

@Slf4j(topic = "c.TestJoin")
public class TestJoin {
    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;
        });
        t1.start();
        t2.start();
        long start = System.currentTimeMillis();
        log.debug("join begin");
        t1.join();
        log.debug("t1 join end");
        t2.join();
        log.debug("t2 join end");
        long end = System.currentTimeMillis();
        log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);// 2s
    }
}

分析如下

• 第一个 join：等待 t1 时, t2 并没有停止, 而在运行
• 第二个 join：1s 后, 执行到此, t2 也运行了 1s, 因此也只需再等待 1s

如果颠倒两个 join 呢？

最终输出的仍然是 2s

图解分析：

2.8.4 有时效的 join

没等够时间

@Slf4j(topic = "c.TestJoin")
public class TestJoin {
    static int r = 0;
    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");
        
        long end = System.currentTimeMillis();
        log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
    }
}

等够时间

t1.join(3000);

2.9 interrupt 方法详解

2.9.1 打断 sleep，wait，join 的线程

这几个方法都会让线程进入阻塞状态，但是打断后，会清空打断状态
以打断 sleep 的线程为例：

@Slf4j(topic = "c.Test11")
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());
    }
}

运行结果：

2.9.2 打断正常运行的线程

打断正常运行的线程, 不会清空打断状态 ，所以我们可以利用标记让线程进行结束。

@Slf4j(topic = "c.Test12")
public class Test12 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (true) {
                boolean interrupted = Thread.currentThread().isInterrupted();
                if(interrupted){//可以通过打断标记 进行打断
                    log.debug("被打断了，退出循环");
                    break;
                }
            }
        }, "t1");
        t1.start();

        Thread.sleep(1000);
        log.debug("interrupt");
        t1.interrupt();//t1的打断标记变为true
    }
}

通过标记打断线程的好处：因为直接把线程终结了，人家线程事情都没干完。不如跟他说一声，说我要打断你，他处理完事情后自行了断不更好。很优雅！

2.9.3 终止模式之两阶段终止模式

Two Phase Termination
在一个线程 T1 中如何“优雅”终止线程 T2？这里的【优雅】指的是给 T2 一个料理后事的机会。

1、错误思路

• 使用线程对象的 stop() 方法停止线程
  • stop 方法会真正杀死线程，如果这时线程锁住了共享资源，那么当它被杀死后就再也没有机会释放锁，其它线程将永远无法获取锁
• 使用 System.exit(int) 方法停止线程
  • 目的仅是停止一个线程，但这种做法会让整个程序都停止

2、两阶段终止模式

图解如下：

• 如果监控线程在阻塞阶段被interrupt，则捕获异常，手动设置打断标记（因为标记会被清除），下一轮料理后事后结束循环。
• 如果监控线程在正常工作阶段被interrupt，则会设置打断标记，下一轮料理后事后结束循环。

2.1 利用 isInterrupted

原理：interrupt 可以打断正在执行的线程，无论这个线程是在 sleep，wait，还是正常运行

代码实现：

@Slf4j(topic = "c.Test10")
public class Test10 {
    public static void main(String[] args) throws InterruptedException {
        TwoPhaseTermination tpt = new TwoPhaseTermination();
        tpt.start();

        Thread.sleep(4000);
        tpt.stop();
    }
}
@Slf4j(topic = "c.TwoPhaseTermination")
class TwoPhaseTermination{
    private Thread monitor;

    //启动监控线程
    public void start(){
        monitor = new Thread(() -> {
            while (true) {
                Thread currentThread = Thread.currentThread();
                if (currentThread.isInterrupted()) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);//情况一:阻塞时interrupt
                    log.debug("执行监控记录");//情况二:正常运行时被interrupt
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    currentThread.interrupt();//阻塞被打断后，程序恢复正常运行。再次被打断，将会有一个打断标记，下一轮会被停止线程。
                }

            }
        });
        monitor.start();
    }

    //停止监控线程
    public void stop(){
        monitor.interrupt();
    }
}

运行结果：

2.2 利用停止标记

后序待补充…

2.9.4 打断 park 线程

打断 park 线程, 不会清空打断状态

@Slf4j(topic = "c.Test11")
public class Test11 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            log.debug("park...");
            LockSupport.park();//线程进入等待状态
            log.debug("unpark...");
            log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
        }, "t1");
        t1.start();

        Thread.sleep(1);
        t1.interrupt();
    }
}

如果打断标记已经是 true, 则 park 会失效

可以使用 Thread.interrupted() 清除打断状态，从而让park继续生效

2.10 不推荐的方法

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

2.11 主线程与守护线程

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

@Slf4j(topic = "c.Test15")
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("结束");
   }
}

注意

• 垃圾回收器线程就是一种守护线程 (当Java的其他线程都结束了，垃圾回收线程也结束)
• Tomcat 中的 Acceptor 和 Poller 线程都是守护线程|（这俩是用来接收和处理请求的），所以 Tomcat 接收到 shutdown 命令后，不会等待它们处理完当前请求。

2.12 五种状态

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

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

2.13 六种状态

这是从 Java API 层面来描述的
根据 Thread.State 枚举，分为六种状态

• NEW 线程刚被创建，但是还没有调用start()方法
• RUNNABLE 当调用了 start() 方法之后，注意，Java API 层面的 RUNNABLE状态涵盖了 操作系统 层面的==【可运行状态】、【运行状态】和【阻塞状态】==（由于 BIO 导致的线程阻塞，在 Java 里无法区分，仍然为
  是可运行）
• 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...");
            }
        };//线程刚被创建还没有调用start()

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

                }
            }
        };//线程正在运行  Runable
        t2.start();

        Thread t3 = new Thread("t3") {
            @Override
            public void run() {
                log.debug("running...");
            }
        };//线程执行完就结束了，对应着TERMINATED
        t3.start();

        Thread t4 = new Thread("t4") {
            @Override
            public void run() {
                synchronized (TestState.class) {
                    try {
                        Thread.sleep(1000000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };//带有时间的等待，对应着timed_waiting
        t4.start();

        Thread t5 = new Thread("t5") {
            @Override
            public void run() {
                try {
                    t2.join(); //等待t2完成后再执行，t2是个死循环，对应着 waiting
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        t5.start();

        Thread t6 = new Thread("t6") {
            @Override
            public void run() {
                synchronized (TestState.class) { //当前锁对象被t2线程占用，t6处于阻塞状态：blocked
                    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();
    }
}

2.14 习题

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

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

附：华罗庚《统筹方法》

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

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

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

哪一种办法省时间？我们能一眼看出，第一种办法好，后两种办法都窝了工。
这是小事，但这是引子，可以引出生产管理等方面有用的方法来。
水壶不洗，不能烧开水，因而洗水壶是烧开水的前提。没开水、没茶叶、不洗茶壶茶杯，就不能泡茶，因而这些又是泡茶的前提。它们的相互关系，可以用下边的箭头图来表示：

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

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

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

看来这是“小题大做”，但在工作环节太多的时候，这样做就非常必要了。
这里讲的主要是时间方面的事，但在具体生产实践中，还有其他方面的许多事。这种方法虽然不一定能直接解决所有问题，但是，我们利用这种方法来考虑问题，也是不无裨益的。

实现代码：

@Slf4j(topic = "c.TestMakeTea")
public class TestMakeTea {

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            log.debug("洗水壶");
            sleep(1);
            log.debug("烧开水");
            sleep(15);//sleep是一个用TimeUnit封装的工具类
        }, "老王");

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

解法1 的缺陷：

• 上面模拟的是小王等老王的水烧开了，小王泡茶。如果反过来要实现老王等小王的茶叶拿来了，老王泡茶
  呢？（也就是一个线程结果作为另外一个线程的条件）代码最好能适应两种情况
• 上面的两个线程其实是各执行各的，如果要模拟老王把水壶交给小王泡茶，或模拟小王把茶叶交给老王泡茶呢（也就是线程间通信）

关于其他解法后续再进行补充…

本章小结

本章的重点在于掌握

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

开发者涨薪指南

48位大咖的思考法则、工作方式、逻辑体系