《Java 并发编程》专栏索引
👉 《Java 并发编程》进程与线程
👉《Java 并发编程》共享模型之管程
👉《Java 并发编程》共享模型之内存
👉《Java 并发编程》共享模型之无锁
👉《Java 并发编程》共享模型之不可变
👉《Java 并发编程》线程池

🚀1. 基本概念

🎉进程

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

🎉线程

• 一个进程之内可以分为多个线程。
• 一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给 CPU 执行。
• 在 Java 中，线程作为 CPU 调度执行的最小单位，进程作为资源拥有的最小单位，在 Windows 中进程是不活动的，只是作为线程的容器。

🎉进程和线程对比：

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

🚀2. 并行与并发

✨单核 CPU 下，线程实际还是串行执行的，操作系统中有一个组件叫做任务调度器，将 CPU 的时间片（Windows 下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 CPU 在线程间（时间片很短）的切换非常快，让人感觉像是在同时运行的。实际就是，微观串行，宏观并行。

✨一般将线程轮流使用 CPU 的做法称为并发（Concurrent）。

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

🎉引用 Rob Pike 的一段描述

并行（Parallel）是同一时间动手做多件事情的能力
并发是同一时间应对多件事情的能力

🎉例如：

• 家庭主妇做饭、打扫卫生、给孩子喂奶，她一个人轮流交替做这多件事，这时就是并发。
• 家庭主妇雇了 2 个保姆，她们一起这些事，这时既有并发，也有并行（这时会产生竞争，例如锅只有一口，一个人用锅时，另一个人就得等待）。
• 雇了 3 个保姆，一个专做饭、一个专打扫卫生、一个专喂奶，互不干扰，这时是并行。

🚀3. 应用

🚁3.1 应用之异步调用

🎉从调用角度来讲，如果

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

（1）设计

多线程可以让方法执行变为异步（即不需要干巴巴等着），例如读取磁盘文件时，假设读取操作花费了 5 秒钟，如果没有线程调度机制，这 5 秒 CPU 什么都做不了，其他代码都需要暂停。

（2）结论

• 例如，在项目中视频文件需要转换格式等操作比较费时，这时开一个新线程处理视频转换，避免阻塞主线程
• tomcat 的异步 servlet 也是类似的操作目的，让用户线程处理耗时较长的操作，避免阻塞 tomcat 的工作线程
• UI 程序中，开线程进行其他操作，避免阻塞 UI 线程

🚁3.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，最后加上汇总时间只会花费 12 ms

值得注意的是，需要在多核 CPU 的前提下才能提高效率，单核 CPU 仍然是轮流执行。

🎉（2）结论

• 单核 CPU 下，多线程不能实际提高程序运行效率，只是为了能够在不同的任务之间切换，不同线程轮流使用 CPU，不至于一个线程总占用 CPU，别的线程没法干活。
• 多核 CPU 可以并行跑多个线程，但能否提高程序运行效率还是要分情况的
  （1）有些任务，经过精心设计，将任务拆分，并行执行，当然可以提高程序的运行效率，但不是所有计算任务都能拆分
  （2）也不是所有任务都需要拆分，任务的目的如果不同，谈拆分和效率也没什么意义

🚀4. 创建线程并运行

🚁4.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 类，那么就不能再继承其他类。另外任务与代码没有分离，当多个线程执行一样的任务时需要多份任务代码。

🚁4.2 使用 Runnable 配合 Thread (推荐)

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

或者

public class CreateThread {
   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 t = new Thread(myRunnable);
      t.start();
   }
}

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

使用 lambda 精简代码

✨当一个接口带有 @FunctionalInterface 注解时，可以使用 lambda 来简化操作。

Runnable 接口源码如下

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

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

原理之 Thread 与 Runnable 的关系

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

public
class Thread implements Runnable {
   //...
}

🎉小结

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

🚁4.3 FutureTask 配合 Thread

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

public class Test {
	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 t = new Thread(futureTask);
        t.start();
        // 获得线程运行后的返回值
        System.out.println(futureTask.get());
    }
}

class MyCall implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "hello world";
    }
}

🚁4.4 小结

✨使用继承方式的好处就是方便传参，可以在子类里面添加成员变量，通过 set 方法设置参数或者通过构造函数进行传递，而如果使用 Runnable 方式，则只能使用主线程里面被声明为 final 的变量。不好的地方是 Java 不支持多继承，如果继承了 Thread 类，那么子类不能再继承其他类，而 Runable 则没有这个限制。前两种方式都没办法拿到任务的返回结果，但是 Futuretask 方式可以返回结果。

🚀5. 原理之线程运行

🎉栈与栈帧

JVM 中由堆、栈、方法区所组成，其中栈内存就是给线程分配的空间，每个线程启动后，虚拟机就会为其分配一块栈内存。

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

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

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

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

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

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

🚀6. 常用方法

🚁6.1 start 与 run

🏳️‍🌈调用 run

public static void main(String[] args) {
     Thread t1 = new Thread("t1") {
         @Override
         public void run() {
             log.debug(Thread.currentThread().getName());
             FileReader.read(Constants.MP4_FULL_PATH);
         }
     };
     t1.run();
     log.debug("do other things");
 }

输出

[main] c.TestStart - main
[main] c.FileReader - read [1.mp4] start ...
[main] c.FileReader - read [1.mp4] end ... cost: 4227 ms
[main] c.TestStart - do other things ...

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

✨调用 start

将上述代码的 t1.run() 改为 t1.start();

输出

[main] c.TestStart - do other things ...
[t1] c.TestStart - t1
[t1] c.FileReader - read [1.mp4] start ...
[t1] c.FileReader - read [1.mp4] end ... cost: 4542 ms

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

🎉小结：

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

🚁6.2 sleep 与 yield

🎉sleep（使线程阻塞）

1. 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
2. 其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException
3. 睡眠结束后的线程未必会立刻得到执行
4. 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性，如

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

🎉yield

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

🎉线程优先级

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

设置优先级的方法

t.setPriority(Thread.MAX_PRIORITY); //设置为优先级最高

🚁6.3 join 方法

✨为什么需要 join？执行下面的代码，打印的 r 是什么？

static int r = 0;
public static void main(String[] args) {
    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

🎉解决方法

• 用 join 方法，加在 t1.start() 之后即可

🎉从调用的角度来讲，如果

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

✨等待多个结果，下面代码大概需要花费多少秒？

static int r1 = 0;
static int r2 = 0;

public static void main(String[] args) {
    test2();
}

private static void test2() throws InterruptedException {
    Thread t1 = new Thread(() -> {
        sleep(1);
        r = 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：1 秒后执行到此，t2 也运行了 1 秒，因此只需要再等待 1 秒

✨如果颠倒两个 join，最后的输出结果都是一样的。

✨其实，join 方法就是用于等待某个线程结束，哪个线程内调用 join 方法，就等待哪个线程结束，然后再去执行其他线程。

如在主线程中调用 thread.join()，则是主线程等待 t1 线程结束。

Thread thread = new Thread();
//等待thread线程执行结束
thread.join();
//最多等待1000ms,如果1000ms内线程执行完毕，则会直接执行下面的语句，不会等够1000ms
thread.join(1000);

🚁6.4 interrupt 方法

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

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

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

✨正常运行的线程在被打断后，不会停止，会继续执行。如果要让线程在被打断后停下来，需要使用打断标记来判断。

while(true) {
    if(Thread.currentThread().isInterrupted()) {
        break;
    }
}

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

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

代码如下

public class Test {
	public static void main(String[] args) throws InterruptedException {
		Monitor monitor = new Monitor();
		monitor.start();
		Thread.sleep(3500);
		monitor.stop();
	}
}

class Monitor {

	Thread monitor;

	/**
	 * 启动监控器线程
	 */
	public void start() {
		//设置监控器线程，用于监控线程状态
		monitor = new Thread() {
			@Override
			public void run() {
				//开始不停的监控
				while (true) {
                    //判断当前线程是否被打断了
					if(Thread.currentThread().isInterrupted()) {
						System.out.println("处理后续任务");
                        //终止线程执行
						break;
					}
					System.out.println("监控器运行中...");
					try {
						//线程休眠
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
						//如果是在休眠的时候被打断，不会将打断标记设置为true，这时要重新设置打断标记
						Thread.currentThread().interrupt();
					}
				}
			}
		};
		monitor.start();
	}

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

🚁6.5 不推荐的打断方法

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

🚁6.6 守护线程

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

//将线程设置为守护线程, 默认为false
monitor.setDaemon(true);

🎉守护线程的应用场景

• 垃圾回收器就是一种守护线程
• Tomcat 中的 Acceptor 和 Poller 线程都是守护线程，所以 Tomcat 接收到 shutdown 命令后，不会等待它们（Acceptor 和 Poller）处理完当前请求

🚀7. 线程状态

🚁7.1 五种状态模型

✨从操作系统层面来描述

（1）【初始状态】仅是在语言层面创建了线程对象，还未与操作系统线程关联

（2）【就绪状态（可运行状态）】，指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行

（3）【运行状态】，指获取了 CPU 时间片运行中的状态

• 当 CPU 时间片用完，会从【运行状态】转换到【可运行状态】，会导致线程的上下文切换

（4）【阻塞状态】

• 如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU，会导致线程上下文切换，进入【阻塞状态】
• 等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至【就绪状态】
• 与【就绪状态】的区别是，对【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑调度它们

（5）【终止状态】表示线程已经执行完毕，生命周期已经结束，不会再转换为其他状态

🚁7.2 六种状态模型

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

• New ：线程刚被创建，但是还没有调用 start() 方法
• RUNNABLE ：当调用了 start() 方法之后（Java API 层面的 RUNNABLE 状态涵盖了操作系统层面的【就绪状态】、【运行状态】和【阻塞状态】），由于 BIO 导致的线程阻塞，在 Java 里无法区分，仍然认为是可运行的
• BLOCKED，WAITING，TIMED_WAITING 都是 Java API 层面对【阻塞状态】的细分
• TERMINATED： 当线程代码运行结束