Java 多线程

Fri, 21 Mar 2025 14:50:07 +0800

参考网站

多线程 - Java教程 - 廖雪峰的官方网站

多数参考了廖老师的博客非常好教程

万字图解Java多线程 - 个人文章 - SegmentFault 思否

相对没那么详细，就讲到同步锁和线程池，简洁清晰

也补充了一些知识，例如线程状态，同步锁，生产者消费者模型……

Java 多线程

进程/线程

进程和线程的关系： 一个进程可以包含一个或多个线程 ，但至少会有一个线程。

操作系统调度的 最小任务单位 其实不是进程，而是线程。常用的Windows、Linux等操作系统都采用抢占式多任务，如何调度线程完全由操作系统决定，程序自己不能决定什么时候执行，以及执行多长时间。

多任务既可以由多进程实现，也可以由单进程内的多线程实现，还可以混合多进程＋多线程

和多线程相比，多进程的缺点在于：

创建进程比创建线程开销大，尤其是在Windows系统上
进程间通信比线程间通信要慢，因为线程间通信就是读写同一个变量，速度很快

多进程的优点在于：

多进程 稳定性 比多线程高，因为在多进程的情况下，一个进程崩溃不会影响其他进程
在多线程的情况下，任何一个线程崩溃会直接导致整个进程崩溃

多线程

Java语言内置了多线程支持：一个Java程序实际上是一个 JVM进程 ，JVM进程用一个主线程来执行main()方法，在main()方法内部，我们又可以启动多个线程。此外，JVM还有负责垃圾回收的其他工作线程等。

和单线程相比，多线程编程的特点在于：多线程经常需要 读写共享数据，并且需要同步 。

例如，播放电影时，就必须由一个线程播放视频，另一个线程播放音频，两个线程需要协调运行，否则画面和声音就不同步。因此，多线程编程的复杂度高，调试更困难。

创建多线程

创建新线程 - Java教程 - 廖雪峰的官方网站

要创建一个新线程非常容易，我们需要实例化一个Thread实例，然后调用它的start()方法：

1
2
3
4
5
6


public class Main {
 public static void main(String args[]) {
 Thread t = new Thread();
 t.start();
 }
}

令新线程能执行指定的代码，有以下几种方法：

方法一 ：从Thread派生一个自定义类，然后覆写run()方法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


public class Main {
 public static void main(String args[]) {
 Thread t = new Thread();
 t.start();
 }
}
class MyThread extends Thread {
 @Overread
 public void run(){
 	System.out.println("start new thread!");
 }
}

执行上述代码，注意到start()方法会在内部自动调用实例的run()方法。

方法二 ：创建Thread实例时，传入一个Runnable实例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


public class Main {
 public static void main(String[] args) {
 Thread t = new Thread(new MyRunnable());
 t.start(); // 启动新线程
 }
}
class MyRunnable implements Runnable {
 @Override
 public void run() {
 System.out.println("start new thread!");
 }
}

或者用Java 8引入的lambda语法进一步简写为：

1
2
3
4
5
6
7
8


public class Main {
 public static void main(String[] args) {
 Thread t = new Thread(() -> {
 System.out.println("start new thread!");
 });
 t.start(); // 启动新线程
 }
}

但是，直接调用 run() 方法，并不能实现多线程，当前线程也不会改变，而只是执行 run() 方法

必须调用Thread实例的start()方法才能启动新线程，如果我们查看Thread类的源代码，会看到start()方法内部调用了一个private native void start0()方法，native修饰符表示这个方法是由JVM虚拟机内部的C代码实现的，不是由Java代码实现的。

使用线程和直接在 main() 方法中执行的区别：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


public class Main {
 public static void main(String[] args) {
 System.out.println("main start...");
 Thread t = new Thread() {
 public void run() {
 System.out.println("thread run...");
 System.out.println("thread end.");
 }
 };
 t.start();
 System.out.println("main end...");
 }
}

main 中命令执行顺序：

打印 main start...
创建 Thread 对象
start 启动新线程
当start()方法被调用时，JVM就创建了一个新线程，我们通过实例变量t来表示这个新线程对象，并开始执行。
打印 main end...

但是，在 t 线程开始运行后， main 和 t 就 同时运行 了，此时程序本身无法确定线程的调度顺序

要模拟并发执行的效果，我们可以在线程中调用Thread.sleep()，参数的单位是毫秒， sleep() 强迫当前线程暂停一段时间：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


public class Main {
 public static void main(String[] args) {
 System.out.println("main start...");
 Thread t = new Thread() {
 public void run() {
 System.out.println("thread run...");
 try {
 Thread.sleep(10);
 } catch (InterruptedException e) {}
 System.out.println("thread end.");
 }
 };
 t.start();
 try {
 Thread.sleep(20);
 } catch (InterruptedException e) {}
 System.out.println("main end...");
 }
}

线程的优先级

1

Thread.setPriority(int n) //默认为5

JVM自动把1（低）~10（高）的优先级映射到操作系统实际优先级上（不同操作系统有不同的优先级数量）。优先级高的线程被操作系统调度的优先级较高，操作系统对高优先级线程可能调度更频繁，但我们 决不能通过设置优先级来确保高优先级的线程一定会先执行 。cpu比较忙时，优先级高的线程获取更多的时间片，cpu比较闲时，优先级设置基本没用

yield() 方法会让运行中的线程切换到就绪状态，重新争抢cpu的时间片，争抢时是否获取到时间片看cpu的分配。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


public static native void yield();

Runnable r1 = () -> {
 int count = 0;
 for (;;){
 log.info("---- 1>" + count++);
 }
};
Runnable r2 = () -> {
 int count = 0;
 for (;;){
 Thread.yield();
 log.info(" ---- 2>" + count++);
 }
};
Thread t1 = new Thread(r1,"t1");
Thread t2 = new Thread(r2,"t2");
t1.start();
t2.start();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


// 运行结果
11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129504
11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129505
11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129506
11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129507
11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129508
11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129509
11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129510
11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129511
11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129512
11:49:15.798 [t2] INFO thread.TestYield - ---- 2>293
11:49:15.798 [t1] INFO thread.TestYield - ---- 1>129513
11:49:15.798 [t1] INFO thread.TestYield - ---- 1>129514
11:49:15.798 [t1] INFO thread.TestYield - ---- 1>129515
11:49:15.798 [t1] INFO thread.TestYield - ---- 1>129516
11:49:15.798 [t1] INFO thread.TestYield - ---- 1>129517
11:49:15.798 [t1] INFO thread.TestYield - ---- 1>129518

如上述结果所示，t2线程每次执行时进行了yield()，线程1执行的机会明显比线程2要多。

小结

Java用Thread对象表示一个线程，通过调用start()启动一个新线程
一个线程对象只能调用一次start()方法
线程的执行代码写在run()方法中
线程调度由操作系统决定，程序本身无法决定调度顺序
Thread.sleep()可以把当前线程暂停一段时间

线程的阻塞

使得线程阻塞的方式有下面几种：

BIO阻塞，即使用了阻塞式的io流
sleep(long time) 让线程休眠进入阻塞状态
a.join() 调用该方法的线程进入阻塞，等待a线程执行完恢复运行
sychronized或ReentrantLock 造成线程未获得锁进入阻塞状态
获得锁之后调用wait()方法也会让线程进入阻塞状态
LockSupport.park() 让线程进入阻塞状态

`Thread.sleep()`

使线程休眠，会将运行中的线程进入阻塞状态。当休眠时间结束后，重新争抢cpu的时间片继续运行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


// 方法的定义 native方法
public static native void sleep(long millis) throws InterruptedException; 

try {
 // 休眠2秒
 // 该方法会抛出 InterruptedException异常 即休眠过程中可被中断，被中断后抛出异常
 Thread.sleep(2000);
 } catch (InterruptedException异常 e) {
 }
 try {
 // 使用TimeUnit的api可替代 Thread.sleep 
 TimeUnit.SECONDS.sleep(1);
 } catch (InterruptedException e) {
 }

`Thread.join()`

一个线程还可以等待另一个线程直到其运行结束。例如，main线程在启动t线程后，可以通过t.join()等待t线程结束后再继续运行：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


public class Main {
 public static void main(String[] args) throws InterruptedException {
 Thread t = new Thread(() -> {
 System.out.println("hello");
 });	//java8 lambda方式
 System.out.println("start");
 t.start(); // 启动t线程
 t.join(); // 此处main线程会等待t结束
 System.out.println("end");
 }
}

当main线程对线程对象t调用join()方法时，主线程将等待变量t表示的线程运行结束，即join就是指等待该线程结束， 然后才继续往下执行自身线程 。所以，上述代码打印顺序可以肯定是main线程先打印start，t线程再打印hello，main线程最后再打印end。

如果t线程已经结束，对实例t调用join()会立刻返回。此外，join(long)的重载方法也可以指定一个等待时间，超过等待时间后就不再继续等待。

小结

线程阻塞的常见方式：BIO阻塞、sleep()、join()、未获取锁（synchronized/ReentrantLock）、wait()、LockSupport.park()。
sleep() ：让线程休眠指定时间，可被中断，推荐用TimeUnit增强可读性。
join() ：让当前线程等待目标线程执行完毕，常用于控制线程执行顺序。
阻塞与恢复：线程进入阻塞后，需等待特定条件（如时间结束、锁释放、目标线程完成）才能恢复运行。

中断线程

中断线程 - Java教程 - 廖雪峰的官方网站

如果线程需要执行一个长时间任务，就可能需要能中断线程。中断线程就是其他线程给该线程发一个信号，该线程收到信号后结束执行run()方法，使得自身线程能立刻结束运行。

例如，从网络下载一个100M的文件，如果网速很慢，用户等得不耐烦，就可能在下载过程中点“取消”，这时，程序就需要中断下载线程的执行。

`Thread.interrupt`

中断一个线程非常简单，只需要在其他线程中对目标线程调用interrupt()方法，目标线程需要反复检测自身状态是否是interrupted状态， 如果是，就立刻结束运行 。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


public class Main {
 public static void main(String[] args) throws InterruptedException {
 Thread t = new MyThread();
 t.start();
 Thread.sleep(1); // 暂停1毫秒
 t.interrupt(); // 中断t线程
 t.join(); // 等待t线程结束
 System.out.println("end");
 }
}

class MyThread extends Thread {
 public void run() {
 int n = 0;
 while (! isInterrupted()) {
 n++;
 System.out.println(n + " hello!");
 }
 }
}

上述代码，main线程通过调用t.interrupt()方法中断t线程，但是要注意，interrupt()方法 仅仅向t线程发出了“中断请求” ，至于t线程 是否能立刻响应，要看具体代码 。而t线程的while循环会检测isInterrupted()，所以上述代码能正确响应interrupt()请求，使得自身立刻结束运行run()方法。

如果线程处于等待状态，例如，t.join()会让main线程进入等待状态，此时，如果对main线程调用interrupt()， join()方法会立刻抛出InterruptedException ，因此，目标线程只要捕获到join()方法抛出的InterruptedException，就说明有其他线程对其调用了interrupt()方法，通常情况下该线程应该立刻结束运行。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


public class Main {
 public static void main(String[] args) throws InterruptedException {
 Thread t = new MyThread();
 t.start();
 Thread.sleep(1000);
 t.interrupt(); // 中断t线程
 t.join(); // 等待t线程结束
 System.out.println("end");
 }
}

class MyThread extends Thread {
 public void run() {
 Thread hello = new HelloThread();
 hello.start(); // 启动hello线程
 try {
 hello.join(); // 等待hello线程结束
 } catch (InterruptedException e) {
 System.out.println("interrupted!");
 }
 hello.interrupt();
 }
}

class HelloThread extends Thread {
 public void run() {
 int n = 0;
 while (!isInterrupted()) {
 n++;
 System.out.println(n + " hello!");
 try {
 Thread.sleep(100);
 } catch (InterruptedException e) {
 break;
 }
 }
 }
}

main线程通过调用t.interrupt()从而通知t线程中断
此时t线程正位于hello.join()的等待中，此方法会立刻结束等待并抛出InterruptedException
在t线程中捕获了InterruptedException，准备结束该线程
t线程结束前，对hello线程也进行了interrupt()调用通知其中断

`running`标志位

另一个常用的中断线程的方法是设置标志位。我们通常会用一个running标志位来标识线程是否应该继续运行，在外部线程中，通过把HelloThread.running置为false，就可以让线程结束：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


public class Main {
 public static void main(String[] args) throws InterruptedException {
 HelloThread t = new HelloThread();
 t.start();
 Thread.sleep(1);
 t.running = false; // 标志位置为false
 }
}

class HelloThread extends Thread {
 public volatile boolean running = true;
 public void run() {
 int n = 0;
 while (running) {
 n ++;
 System.out.println(n + " hello!");
 }
 System.out.println("end!");
 }
}

注意到HelloThread的标志位boolean running是一个 线程间共享的变量 。线程间共享变量需要使用volatile关键字标记，确保 每个线程都能读取到更新后的变量值 。

`volatile` 的用处

为什么要对线程间共享的变量用关键字volatile声明？这涉及到Java的内存模型。在Java虚拟机中，变量的值保存在主内存中，但是，当线程访问变量时，它会先获取一个副本，并保存在自己的工作内存中。如果线程修改了变量的值，虚拟机会在某个时刻把修改后的值回写到主内存，但是， 这个时间是不确定的 ！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


// 这图画得真有水平罢 
┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐
 Main Memory
│ │
 ┌───────┐┌───────┐┌───────┐
│ │ var A ││ var B ││ var C │ │
 └───────┘└───────┘└───────┘
│ │ ▲ │ ▲ │
 ─ ─ ─│─│─ ─ ─ ─ ─ ─ ─ ─│─│─ ─ ─
 │ │ │ │
┌ ─ ─ ┼ ┼ ─ ─ ┐ ┌ ─ ─ ┼ ┼ ─ ─ ┐
 ▼ │ ▼ │
│ ┌───────┐ │ │ ┌───────┐ │
 │ var A │ │ var C │
│ └───────┘ │ │ └───────┘ │
 Thread 1 Thread 2
└ ─ ─ ─ ─ ─ ─ ┘ └ ─ ─ ─ ─ ─ ─ ┘

这会导致如果一个线程更新了某个变量，另一个线程读取的值可能还是更新前的。

例如，主内存的变量a = true，线程1执行a = false时，它在此刻仅仅是把变量a的副本变成了false，主内存的变量a还是true，在JVM把修改后的a回写到主内存之前，其他线程读取到的a的值仍然是true，这就造成了 多线程之间共享的变量不一致 。

因此，volatile关键字的目的是告诉虚拟机：

每次访问变量时，总是获取主内存的最新值；
每次修改变量后，立刻回写到主内存。

volatile关键字解决的是可见性问题：当一个线程 修改了某个共享变量的值，其他线程能够立刻看到修改后的值 。

如果我们去掉volatile关键字，运行上述程序，发现效果和带volatile差不多，这是因为在x86的架构下，JVM回写主内存的速度非常快，但是，换成ARM的架构，就会有显著的延迟。

小结

对目标线程调用interrupt()方法可以请求中断一个线程，目标线程通过检测isInterrupted()标志获取自身是否已中断。如果目标线程处于等待状态，该线程会捕获到InterruptedException；

目标线程检测到isInterrupted()为true或者捕获了InterruptedException都应该立刻结束自身线程；

通过标志位判断需要正确使用volatile关键字；

volatile关键字解决了共享变量在线程间的可见性问题。

线程状态

万字图解Java多线程 - 个人文章 - SegmentFault 思否

线程的状态 - Java教程 - 廖雪峰的官方网站

系统 - 五种状态

线程的状态可从操作系统层面分为五种状态

初始状态：创建线程对象时的状态
可运行状态(就绪状态)：调用 start() 方法后进入就绪状态，也就是准备好被cpu调度执行
运行状态：线程获取到cpu的时间片，执行 run() 方法的逻辑
阻塞状态: 线程被阻塞，放弃cpu的时间片，等待解除阻塞重新回到就绪状态争抢时间片
终止状态: 线程执行完成或抛出异常后的状态

Java - 六种状态

在Java程序中，一个线程对象只能调用一次start()方法启动新线程，并在新线程中执行run()方法。一旦run()方法执行完毕，线程就结束了。因此，Java线程的状态有以下几种：

NEW 线程对象被创建
Runnable 线程调用了 start() 方法后进入该状态，该状态包含了三种情况
1. 就绪状态 :等待cpu分配时间片
2. 运行状态:进入Runnable方法执行任务
3. 阻塞状态:BIO 执行阻塞式io流时的状态
Blocked 没获取到锁时的阻塞状态(同步锁章节会细说)
WAITING 调用 wait() join() 等方法后的状态
TIMED_WAITING 调用 sleep(time) wait(time) join(time) 等方法后的状态
TERMINATED 线程执行完成或抛出异常后的状态

当线程启动后，它可以在Runnable、Blocked、Waiting和Timed Waiting这几个状态之间切换，直到最后变成Terminated状态，线程终止。

线程终止的原因有：

线程正常终止：run()方法执行到return语句返回；
线程意外终止：run()方法因为未捕获的异常导致线程终止；
对某个线程的Thread实例调用stop()方法强制终止（强烈不推荐使用）。

Thread类中的核心方法

方法名称	是否static	方法说明
start()	否	让线程启动，进入就绪状态,等待cpu分配时间片
run()	否	重写Runnable接口的方法,线程获取到cpu时间片时执行的具体逻辑
yield()	是	线程的礼让，使得获取到cpu时间片的线程进入就绪状态，重新争抢时间片
sleep(time)	是	线程休眠固定时间，进入阻塞状态，休眠时间完成后重新争抢时间片,休眠可被打断
join()/join(time)	否	调用线程对象的join方法，调用者线程进入阻塞,等待线程对象执行完或者到达指定时间才恢复，重新争抢时间片
isInterrupted()	否	获取线程的打断标记，true:被打断，false：没有被打断。调用后不会修改打断标记
interrupt()	否	打断线程，抛出InterruptedException异常的方法均可被打断，但是打断后不会修改打断标记，正常执行的线程被打断后会修改打断标记
interrupted()	否	获取线程的打断标记。调用后会清空打断标记
stop()	否	停止线程运行不推荐
suspend()	否	挂起线程不推荐
resume()	否	恢复线程运行不推荐
currentThread()	是	获取当前线程

Object中与线程相关方法

方法名称	方法说明
wait()/wait(long timeout)	获取到锁的线程进入阻塞状态
notify()	随机唤醒被wait()的一个线程
notifyAll();	唤醒被wait()的所有线程，重新争抢时间片

守护线程

守护线程 - Java教程 - 廖雪峰的官方网站

Java程序入口就是由JVM启动main线程，main线程又可以启动其他线程。当所有线程都运行结束时，JVM退出，进程结束。

如果有一个线程没有退出，JVM进程就不会退出。所以，必须保证所有线程都能及时结束。

但是有一种线程的目的就是无限循环，例如，一个定时触发任务的线程：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class TimerThread extends Thread {
 @Override
 public void run() {
 while (true) {
 System.out.println(LocalTime.now());
 try {
 Thread.sleep(1000);
 } catch (InterruptedException e) {
 break;
 }
 }
 }
}

如果这个线程不结束，JVM进程就无法结束。问题是，由谁负责结束这个线程？

然而这类线程经常没有负责人来负责结束它们。但是，当其他线程结束时，JVM进程又必须要结束，怎么办？

答案是使用守护线程（Daemon Thread）。

守护线程是指为其他线程服务的线程。在JVM中， 所有非守护线程都执行完毕后 ，无论有没有守护线程，虚拟机都会自动退出。

因此，JVM退出时，不必关心守护线程是否已结束。

如何创建守护线程呢？方法和普通线程一样，只是在调用start()方法前， 调用setDaemon(true)把该线程标记为守护线程 ：

1
2
3


Thread t = new MyThread();
t.setDaemon(true);
t.start();

在守护线程中，编写代码要注意： 守护线程不能持有任何需要关闭的资源 ，例如打开文件等，因为虚拟机退出时，守护线程没有任何机会来关闭文件，这会导致数据丢失。

小结

守护线程是为其他线程服务的线程；

所有非守护线程都执行完毕后，虚拟机退出，守护线程随之结束；

守护线程不能持有需要关闭的资源（如打开文件等）。

线程同步

线程同步 - Java教程 - 廖雪峰的官方网站

当多个线程同时运行时，线程的调度由操作系统决定，程序本身无法决定。因此，任何一个线程都有可能在任何指令处被操作系统暂停，然后在某个时间段后继续执行。

这个时候，有个单线程模型下不存在的问题就来了：如果多个线程同时读写共享变量，会出现数据不一致的问题。

我们来看一个例子：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


// 多线程
public class Main {
 public static void main(String[] args) throws Exception {
 var add = new AddThread();
 var dec = new DecThread();
 add.start();
 dec.start();
 add.join();
 dec.join();
 System.out.println(Counter.count);
 }
}

class Counter {
 public static int count = 0;
}

class AddThread extends Thread {
 public void run() {
 for (int i=0; i<10000; i++) { Counter.count += 1; }
 }
}

class DecThread extends Thread {
 public void run() {
 for (int i=0; i<10000; i++) { Counter.count -= 1; }
 }
}

上面的代码很简单，两个线程同时对一个int变量进行操作，一个加10000次，一个减10000次，最后结果应该是0，但是，每次运行，结果实际上都是不一样的。

这是因为对变量进行读取和写入时，结果要正确， 必须保证是原子操作 。原子操作是指不能被中断的一个或一系列操作。

例如，对于语句：

1

n = n + 1;

看上去是一行语句，实际上对应了3条指令：

1
2
3


ILOAD
IADD
ISTORE

我们假设n的值是100，如果两个线程同时执行n = n + 1，得到的结果很可能不是102，而是101，原因在于：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


┌───────┐ ┌───────┐
│Thread1│ │Thread2│
└───┬───┘ └───┬───┘
 │ │
 │ILOAD (100) │
 │ │ILOAD (100)
 │ │IADD
 │ │ISTORE (101)
 │IADD │
 │ISTORE (101) │
 ▼ ▼

如果线程1在执行ILOAD后被操作系统中断，此刻如果线程2被调度执行，它执行ILOAD后获取的值仍然是100，最终结果被两个线程的ISTORE写入后变成了101，而不是期待的102。

这说明多线程模型下，要保证逻辑正确，对共享变量进行读写时， 必须保证一组指令以原子方式执行：即某一个线程执行时，其他线程必须等待 ：

`synchronized 同步锁`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


┌───────┐ ┌───────┐
│Thread1│ │Thread2│
└───┬───┘ └───┬───┘
 │ │
 │-- lock -- │
 │ILOAD (100) │
 │IADD │
 │ISTORE (101) │
 │-- unlock -- │
 │ │-- lock --
 │ │ILOAD (101)
 │ │IADD
 │ │ISTORE (102)
 │ │-- unlock --
 ▼ ▼

通过加锁和解锁的操作，就能保证3条指令总是在一个线程执行期间，不会有其他线程会进入此指令区间。即使在执行期线程被操作系统中断执行，其他线程也会因为无法获得锁导致无法进入此指令区间。只有执行线程将锁释放后，其他线程才有机会获得锁并执行。这种加锁和解锁之间的代码块我们称之为临界区(Critical Section)，任何时候临界区最多只有一个线程能执行。

可见， 保证一段代码的原子性就是通过加锁和解锁实现的 。Java程序使用synchronized关键字对一个对象进行加锁：

1
2
3


synchronized(lock) {
 n = n + 1;
}

synchronized保证了代码块在 任意时刻最多只有一个线程能执行 。我们把上面的代码用synchronized改写如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


// 多线程
public class Main {
 public static void main(String[] args) throws Exception {
 var add = new AddThread();
 var dec = new DecThread();
 add.start();
 dec.start();
 add.join();
 dec.join();
 System.out.println(Counter.count);
 }
}

class Counter {
 public static final Object lock = new Object();
 public static int count = 0;
}

class AddThread extends Thread {
 public void run() {
 for (int i=0; i<10000; i++) {
 synchronized(Counter.lock) {
 Counter.count += 1;
 }
 }
 }
}

class DecThread extends Thread {
 public void run() {
 for (int i=0; i<10000; i++) {
 synchronized(Counter.lock) {
 Counter.count -= 1;
 }
 }
 }
}

注意到代码：

1
2
3


synchronized(Counter.lock) { // 获取锁
 ...
} // 释放锁

它表示用Counter.lock实例作为锁，两个线程在执行各自的synchronized(Counter.lock) { ... }代码块时，必须先获得锁，才能进入代码块进行。执行结束后，在synchronized语句块结束会自动释放锁。这样一来，对Counter.count变量进行读写就不可能同时进行。上述代码无论运行多少次，最终结果都是0。

使用synchronized解决了多线程同步访问共享变量的正确性问题。但是，它的缺点是带来了性能下降。因为synchronized代码块无法并发执行。此外，加锁和解锁需要消耗一定的时间，所以，synchronized会降低程序的执行效率。

我们来概括一下如何使用synchronized：

找出修改共享变量的线程代码块；
选择一个共享实例作为锁；
使用synchronized(lockObject) { ... }。

在使用synchronized的时候， 不必担心抛出异常 。因为无论是否有异常，都会在synchronized结束处正确释放锁：

1
2
3
4
5
6
7
8


public void add(int m) {
 synchronized (obj) {
 if (m < 0) {
 throw new RuntimeException();
 }
 this.value += m;
 } // 无论有无异常，都会在此释放锁
}

此外，多个线程各自都可以同时获得锁：因为JVM只保证同一个锁在任意时刻只能被一个线程获取， 但两个不同的锁在同一时刻可以被两个线程分别获取 。

因此，使用synchronized的时候， 获取到的是哪个锁非常重要 。锁对象如果不对，代码逻辑就不对。

下面是应用了两个不同的锁来提升效率的示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60


public class Main {
 public static void main(String[] args) throws Exception {
 var ts = new Thread[] { new AddStudentThread(), new DecStudentThread(), new AddTeacherThread(), new DecTeacherThread() };
 for (var t : ts) {
 t.start();
 }
 for (var t : ts) {
 t.join();
 }
 System.out.println(Counter.studentCount);
 System.out.println(Counter.teacherCount);
 }
}

class Counter {
 public static final Object lockStudent = new Object();
 public static final Object lockTeacher = new Object();
 public static int studentCount = 0;
 public static int teacherCount = 0;
}

class AddStudentThread extends Thread {
 public void run() {
 for (int i=0; i<10000; i++) {
 synchronized(Counter.lockStudent) {
 Counter.studentCount += 1;
 }
 }
 }
}

class DecStudentThread extends Thread {
 public void run() {
 for (int i=0; i<10000; i++) {
 synchronized(Counter.lockStudent) {
 Counter.studentCount -= 1;
 }
 }
 }
}

class AddTeacherThread extends Thread {
 public void run() {
 for (int i=0; i<10000; i++) {
 synchronized(Counter.lockTeacher) {
 Counter.teacherCount += 1;
 }
 }
 }
}

class DecTeacherThread extends Thread {
 public void run() {
 for (int i=0; i<10000; i++) {
 synchronized(Counter.lockTeacher) {
 Counter.teacherCount -= 1;
 }
 }
 }
}

不需要 `synchronized` 的操作

JVM规范定义了几种原子操作：

基本类型（long和double除外）赋值，例如：int n = m；
引用类型赋值，例如：List<String> list = anotherList。

long和double是64位数据，JVM没有明确规定64位赋值操作是不是一个原子操作，不过在x64平台的JVM是把long和double的赋值作为原子操作实现的。

单条原子操作的语句不需要同步。例如：

1
2
3
4
5


public void set(int m) {
 synchronized(lock) {
 this.value = m;
 }
}

就不需要同步。

对引用也是类似。例如：

1
2
3


public void set(String s) {
 this.value = s;
}

上述 赋值语句 并不需要同步。

但是，如果是 多行赋值语句，就必须保证是同步操作 ，例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


class Point {
 int x;
 int y;
 public void set(int x, int y) {
 synchronized(this) {
 this.x = x;
 this.y = y;
 }
 }
 public int[] get() {
 synchronized(this) {
 return new int[]{x,y};
 }
 }
}

上面的读写，即( set(), get() )需要同步，在读的时候若是不同步，会造成程序的逻辑错误：

1
2
3
4
5


public int[] get() {
 int[] copy = new int[2];
 copy[0] = x;
 copy[1] = y;
 }

假定当前坐标是(100, 200)，那么当设置新坐标为(110, 220)时，上述未同步的多线程读到的值可能有：

(100, 200)：x，y更新前；
(110, 200)：x更新后，y更新前；
(110, 220)：x，y更新后。

如果读取到(110, 200)，即读到了更新后的x，更新前的y，无法保证读取的多个变量状态保持一致。

有些时候，通过一些巧妙的转换，可以把非原子操作变为原子操作。例如，上述代码如果改造成：

1
2
3
4
5
6
7


class Point {
 int[] ps;
 public void set(int x, int y) {
 int[] ps = new int[] { x, y };
 this.ps = ps;
 }
}

就不再需要写同步，因为this.ps = ps是引用赋值的原子操作。而语句：

1

int[] ps = new int[] { x, y };

这里的ps是方法内部定义的局部变量，每个线程都会有各自的局部变量，互不影响，并且互不可见，并不需要同步。

不过要注意，读方法在复制int[]数组的过程中仍然需要同步。

不可变对象无需同步

不可变对象是指创建后状态不能被修改的对象。在 Java 中，典型的不可变对象包括：

String
List.of() 创建的不可变集合（Java 9+）
基本类型的包装类（如 Integer, Long 等）

如果多线程读写的是一个不可变对象，那么无需同步，因为不会修改对象的状态：

1
2
3
4
5
6
7
8
9


class Data {
 List<String> names;
 void set(String[] names) {
 this.names = List.of(names);
 }
 List<String> get() {
 return this.names;
 }
}

注意到set()方法内部创建了一个不可变List，这个List包含的对象也是不可变对象String，因此，整个List<String>对象都是不可变的，因此读写均无需同步。

分析变量是否能被多线程访问时，首先要理清概念，多线程同时执行的是方法。对于下面这个例子：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


class Status {
 List<String> names;
 int x;
 int y;
 void set(String[] names, int n) {
 List<String> ns = List.of(names);
 this.names = ns;
 int step = n * 10;
 this.x += step;
 this.y += step;
 }
 StatusRecord get() {
 return new StatusRecord(this.names, this.x, this.y);
 }
}

如果有A、B两个线程，同时执行是指：

可能同时执行set()；
可能同时执行get()；
可能A执行set()，同时B执行get()。

类的成员变量names、x、y显然能被多线程同时读写，但局部变量（包括方法参数）如果没有“逃逸”，那么只有当前线程可见。局部变量step仅在set()方法内部使用，因此每个线程同时执行set时都有一份独立的step存储在线程的栈上，互不影响，

局部变量ns虽然每个线程也各有一份，但后续赋值 this.names = ns 对其他线程就变成可见了。对set()方法同步时，如果要最小化synchronized代码块，可以改写如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


void set(String[] names, int n) {
 // 局部变量其他线程不可见:
 List<String> ns = List.of(names);
 int step = n * 10;
 synchronized(this) {
 this.names = ns;
 this.x += step;
 this.y += step;
 }
}

因此，深入理解多线程还需理解变量在栈上的存储方式，基本类型和引用类型的存储方式也不同。

场景	是否需要同步	原因
不可变对象（如 `List.of()`）	否	对象不可变，多线程只能读取，无竞态条件。
局部变量（如 `step`）	否	线程私有，栈封闭。
成员变量赋值（如 `this.names`）	是	引用可能被多线程同时修改，需同步或 `volatile`。
复合操作（如 `x += step`）	是	非原子操作（读取-修改-写入），需同步。

小结

多线程同时读写共享变量时，可能会造成逻辑错误，因此需要通过synchronized同步；

同步的本质就是给指定对象加锁，加锁后才能继续执行后续代码；

注意加锁对象必须是同一个实例；

对JVM定义的单个原子操作不需要同步。

线程同步方法

线程安全

如果一个类被设计为允许多线程正确访问，我们就说这个类就是“线程安全”的（thread-safe），Java标准库的java.lang.StringBuffer也是线程安全的。

还有一些 不变类 ，例如String，Integer，LocalDate，它们的所有成员变量都是final，多线程同时访问时只能读不能写，这些不变类也是线程安全的。

最后，类似Math这些 只提供静态方法，没有成员变量的类 ，也是线程安全的。

除了上述几种少数情况，大部分类，例如ArrayList，都是 非线程安全的类 ，我们不能在多线程中修改它们。但是，如果所有线程都 只读取，不写入 ，那么ArrayList是可以安全地在线程间共享的。

没有特殊说明时，一个类 默认是非线程安全的 。

例如下面的Counter类：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


public class Counter {
 private int count = 0;

 public void add(int n) {
 synchronized(this) {
 count += n;
 }
 }

 public void dec(int n) {
 synchronized(this) {
 count -= n;
 }
 }

 public int get() {
 return count;
 }
}

这样一来，线程调用add()、dec()方法时，它不必关心同步逻辑，因为synchronized代码块在add()、dec()方法内部。并且，我们注意到，synchronized锁住的对象是this，即当前实例，这又使得创建多个Counter实例的时候，它们之间互不影响，可以并发执行

`synchronized` 修饰

我们再观察Counter的代码：

1
2
3
4
5
6
7
8


public class Counter {
 public void add(int n) {
 synchronized(this) {
 count += n;
 }
 }
 ...
}

当我们锁住的是this实例时，实际上可以用synchronized修饰这个方法。下面两种写法是等价的：

1
2
3
4
5


public void add(int n) {
 synchronized(this) { // 锁住this
 count += n;
 } // 解锁
}

写法二：

1
2
3


public synchronized void add(int n) { // 锁住this
 count += n;
} // 解锁

因此， 用synchronized修饰的方法就是同步方法 ，它表示整个方法都必须用this实例加锁。

对于static方法，是没有this实例的，因为static方法是针对类而不是实例。但是我们注意到任何一个类都有一个由JVM自动创建的Class实例，因此， 对static方法添加synchronized，锁住的是该类的Class实例 。上述synchronized static方法实际上相当于：

1
2
3
4
5
6
7


public class Counter {
 public static void test(int n) {
 synchronized(Counter.class) {
 ...
 }
 }
}

小结

用synchronized修饰方法可以把整个方法变为同步代码块，synchronized方法加锁对象是this；

通过合理的设计和数据封装可以让一个类变为“线程安全”；

一个类没有特殊说明，默认不是thread-safe；

多线程能否安全访问某个非线程安全的实例，需要具体问题具体分析。

死锁

可重入锁

Java的线程锁是可重入的锁。

什么是可重入的锁？我们还是来看例子：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


public class Counter {
 private int count = 0;

 public synchronized void add(int n) {
 if (n < 0) {
 dec(-n);
 } else {
 count += n;
 }
 }

 public synchronized void dec(int n) {
 count += n;
 }
}

执行流程：

调用add(-1)：
- 获取this锁：计数器=1，持有线程=当前线程
进入add方法后调用dec(1)：
- 再次获取this锁：发现当前线程已持有，计数器增加到2
退出dec方法：
- 计数器减到1
退出add方法：
- 计数器减到0，真正释放锁

观察synchronized修饰的add()方法，一旦线程执行到add()方法内部，说明它已经获取了当前实例的this锁。如果传入的n < 0，将在add()方法内部调用dec()方法。由于dec()方法也需要获取this锁，现在问题来了：

对同一个线程，能否在获取到锁以后继续获取同一个锁？

答案是肯定的。 JVM允许同一个线程重复获取同一个锁 ，这种能被同一个线程反复获取的锁，就叫做可重入锁。

由于Java的线程锁是可重入锁，所以，获取锁的时候，不但要判断是否是第一次获取，还要记录这是第几次获取。每获取一次锁，记录+1，每退出synchronized块，记录-1，减到0的时候，才会真正释放锁。

死锁

一个线程可以获取一个锁后，再继续获取另一个锁。例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


public void add(int m) {
 synchronized(lockA) { // 获得lockA的锁
 this.value += m;
 synchronized(lockB) { // 获得lockB的锁
 this.another += m;
 } // 释放lockB的锁
 } // 释放lockA的锁
}

public void dec(int m) {
 synchronized(lockB) { // 获得lockB的锁
 this.another -= m;
 synchronized(lockA) { // 获得lockA的锁
 this.value -= m;
 } // 释放lockA的锁
 } // 释放lockB的锁
}

在获取多个锁的时候，不同线程获取多个不同对象的锁可能导致死锁。对于上述代码，线程1和线程2如果分别执行add()和dec()方法时：

线程1：进入add()，获得lockA；
线程2：进入dec()，获得lockB。

随后：

线程1：准备获得lockB，失败，等待中；
线程2：准备获得lockA，失败，等待中。

此时，两个线程各自持有不同的锁，然后各自试图获取对方手里的锁，造成了双方无限等待下去，这就是死锁。

死锁发生后，没有任何机制能解除死锁，只能强制结束JVM进程。

因此，在编写多线程应用时，要特别注意防止死锁。因为死锁一旦形成，就只能强制结束进程。

那么我们应该如何避免死锁呢？答案是： 线程获取锁的顺序要一致 。即严格按照先获取lockA，再获取lockB的顺序，改写dec()方法如下：

1
2
3
4
5
6
7
8


public void dec(int m) {
 synchronized(lockA) { // 获得lockA的锁
 this.value -= m;
 synchronized(lockB) { // 获得lockB的锁
 this.another -= m;
 } // 释放lockB的锁
 } // 释放lockA的锁
}

小结

Java的synchronized锁是可重入锁；

死锁产生的条件是多线程各自持有不同的锁，并互相试图获取对方已持有的锁，导致无限等待；

避免死锁的方法是多线程获取锁的顺序要一致。

线程通信

在Java程序中，synchronized解决了多线程竞争的问题。例如，对于一个任务管理器，多个线程同时往队列中添加任务，可以用synchronized加锁：

1
2
3
4
5
6
7


class TaskQueue {
 Queue<String> queue = new LinkedList<>();

 public synchronized void addTask(String s) {
 this.queue.add(s);
 }
}

但是synchronized并没有解决多线程协调的问题。

仍然以上面的TaskQueue为例，我们再编写一个getTask()方法取出队列的第一个任务：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class TaskQueue {
 Queue<String> queue = new LinkedList<>();

 public synchronized void addTask(String s) {
 this.queue.add(s);
 }

 public synchronized String getTask() {
 while (queue.isEmpty()) {
 }
 return queue.remove();
 }
}

上述代码看上去没有问题：getTask()内部先判断队列是否为空，如果为空，就循环等待，直到另一个线程往队列中放入了一个任务，while()循环退出，就可以返回队列的元素了。

但实际上while()循环永远不会退出。因为线程在执行while()循环时，已经在getTask()入口获取了this锁，其他线程根本无法调用addTask()，因为addTask()执行条件也是获取this锁。

因此，执行上述代码，线程会在getTask()中因为死循环而100%占用CPU资源。

如果深入思考一下，我们想要的执行效果是：

线程1可以调用addTask()不断往队列中添加任务；
线程2可以调用getTask()从队列中获取任务。如果队列为空，则getTask()应该等待，直到队列中至少有一个任务时再返回。

因此，多线程协调运行的原则就是：当条件不满足时，线程进入等待状态；当条件满足时，线程被唤醒，继续执行任务。

`wait()`

对于上述TaskQueue，我们先改造getTask()方法，在条件不满足时，线程进入等待状态：

1
2
3
4
5
6


public synchronized String getTask() {
 while (queue.isEmpty()) {
 this.wait();
 }
 return queue.remove();
}

当一个线程执行到getTask()方法内部的while循环时，它必定已经获取到了this锁，此时，线程执行while条件判断，如果条件成立（队列为空），线程将执行this.wait()，进入等待状态。

这里的关键是：wait()方法必须在 当前获取的锁对象 上调用，这里获取的是this锁，因此调用this.wait()。

调用wait()方法后，线程进入等待状态，wait()方法不会返回，直到将来某个时刻， 线程从等待状态被其他线程唤醒后 ，wait()方法才会返回，然后，继续执行下一条语句。

有些仔细的童鞋会指出：即使线程在getTask()内部等待，其他线程如果拿不到this锁，照样无法执行addTask()，肿么办？

这个问题的关键就在于wait()方法的执行机制非常复杂。首先，它不是一个普通的Java方法，而是定义在Object类的一个native方法，也就是由JVM的C代码实现的。其次，必须在synchronized块中才能调用wait()方法， 因为wait()方法调用时，会释放线程获得的锁 ，wait()方法返回时，线程又会重新试图获得锁。

因此，只能在锁对象上调用wait()方法。因为在getTask()中，我们获得了this锁，因此，只能在this对象上调用wait()方法：

1
2
3
4
5
6
7
8


public synchronized String getTask() {
 while (queue.isEmpty()) {
 // 释放this锁:
 this.wait();
 // 重新获取this锁
 }
 return queue.remove();
}

当一个线程在this.wait()等待时，它就会释放this锁，从而使得其他线程能够在addTask()方法获得this锁。

`notify()`

现在我们面临第二个问题：如何让等待的线程被 重新唤醒 ，然后从wait()方法返回？答案是在相同的锁对象上调用notify()方法。我们修改addTask()如下：

1
2
3
4


public synchronized void addTask(String s) {
 this.queue.add(s);
 this.notify(); // 唤醒在this锁等待的线程
}

注意到在往队列中添加了任务后，线程立刻对this锁对象调用notify()方法，这个方法会唤醒一个正在this锁等待的线程（就是在getTask()中位于this.wait()的线程），从而使得等待线程从this.wait()方法返回。

我们来看一个完整的例子(这也是一个生产者消费者模型)：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56


import java.util.*;

public class Main {
 public static void main(String[] args) throws InterruptedException {
 var q = new TaskQueue();
 var ts = new ArrayList<Thread>();
 for (int i=0; i<5; i++) {
 var t = new Thread() {
 public void run() {
 // 执行task:
 while (true) {
 try {
 String s = q.getTask();
 System.out.println("execute task: " + s);
 } catch (InterruptedException e) {
 return;
 }
 }
 }
 };
 t.start();
 ts.add(t);
 }
 var add = new Thread(() -> {
 for (int i=0; i<10; i++) {
 // 放入task:
 String s = "t-" + Math.random();
 System.out.println("add task: " + s);
 q.addTask(s);
 try { Thread.sleep(100); } catch(InterruptedException e) {}
 }
 });
 add.start();
 add.join();
 Thread.sleep(100);
 for (var t : ts) {
 t.interrupt();
 }
 }
}

class TaskQueue {
 Queue<String> queue = new LinkedList<>();

 public synchronized void addTask(String s) {
 this.queue.add(s);
 this.notifyAll();
 }

 public synchronized String getTask() throws InterruptedException {
 while (queue.isEmpty()) {
 this.wait();
 }
 return queue.remove();
 }
}

这个例子中，我们重点关注addTask()方法，内部调用了this.notifyAll()而不是this.notify()，使用notifyAll()将唤醒所有当前正在this锁等待的线程，而notify()只会 唤醒其中一个 （具体哪个依赖操作系统，有一定的 随机性）。这是因为可能有多个线程正在getTask()方法内部的wait()中等待，使用notifyAll()将 一次性全部唤醒 。通常来说，notifyAll()更安全。有些时候，如果我们的代码逻辑考虑不周，用notify()会导致只唤醒了一个线程，而其他线程可能永远等待下去醒不过来了。

但是，注意到wait()方法返回时需要重新获得this锁。假设当前有3个线程被唤醒，唤醒后，首先要等待执行addTask()的线程结束此方法后，才能释放this锁，随后，这3个线程中只能有一个获取到this锁，剩下两个将继续等待。

再注意到我们在while()循环中调用wait()，而不是if语句：

1
2
3
4
5
6


public synchronized String getTask() throws InterruptedException {
 if (queue.isEmpty()) {
 this.wait();
 }
 return queue.remove();
}

这种写法实际上是错误的，因为线程被唤醒时，需要再次获取this锁。多个线程被唤醒后，只有一个线程能获取this锁，此刻，该线程执行queue.remove()可以获取到队列的元素，然而，剩下的线程如果获取this锁后执行queue.remove()，此刻队列可能已经没有任何元素了，所以，要始终在while循环中wait()，并且每次被唤醒后拿到this锁就必须再次判断：

1
2
3


while (queue.isEmpty()) {
 this.wait();
}

小结

wait和notify用于多线程协调运行：

在synchronized内部可以调用wait()使线程进入等待状态；
必须在已获得的锁对象上调用wait()方法；
在synchronized内部可以调用notify()或notifyAll()唤醒其他等待线程；
必须在已获得的锁对象上调用notify()或notifyAll()方法；
已唤醒的线程还需要重新获得锁后才能继续执行。

生产者消费者模型

Java生产者消费者模式的实现和解析_哔哩哔哩_bilibili

下面是从B站找来的简单的生产者消费者模型的示例，并不如上面线程通信中的示例以及下面的消息队列模型示例，这三个示例我想就能拿下该模型罢

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


public class Demo1 {
 /**
 * 交替执行两个线程
 * 一个输出“1,2,3,...”
 * 一个输出“a,b,c,...”
 */
 public static void main(String[] args) {
 Factory factory = new Factory();

 final Thread t1 = new Thread(new Runnable() {
 @Override
 public void run() {
 for(int i = 1;i <= 26;i++){
 factory.product(i);
 }
 }
 });

 final Thread t2 = new Thread(new Runnable() {
 @Override
 public void run() {
 for(int i = 'a';i <= 'z';i++){
 factory.consume((char) i);
 }
 }
 });
 t1.start();
 t2.start();
 }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


public class Factory {
 /**
 * 0: 生产者正在生成，消费者正在等待，生产者结束生产后告知消费者进行消费
 * 1: 消费者正在消费，生产者正在等待，消费者结束消费后高职生产者进行生产
 */
 private int sign = 0;	//状态值


 public synchronized void product(int n){
 if(sign == 1){
 try {
 this.wait();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 System.out.print(n);
 this.notify();
 this.sign = 1;
 }

 public synchronized void consume(char c){
 if(sign == 0){
 try {
 this.wait();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 System.out.print(c);
 this.notify();
 this.sign = 0;
 }
}

线程的运行有一定随机性，往往用户无法决定，但是生产者消费者模型，能实现两个线程的“交替”运行

注释里的内容不再概述，我们来分析一下：

假设线程 t1 先被调用，由于 sign = 0 ，所以打印字符 1 ， sign 变为1。下面有两种可能，调用线程 t1 或 t2

调用 t1 :

sign = 1 进入 try/catch
同步锁的对象 this。wait() 也就是进入 “等待” 状态
wait() 会 释放锁 ，线程 t2 执行，运行 consume()
notfiy() 唤醒 this 中等待的线程 t1
sign 被赋值0，周而复始

调用 t2 :

线程 t2 执行，运行 consume()
notify 不唤醒任一线程(因为无线程处于等待状态)
sign 被赋值0，周而复始

示例分析

下面是较复杂(贴切实际)的一种，思想和上面简单的例子差不多的

关于下面示例中 lambda 表达式创建线程的方式，需要补充几点：

new Thread() - 创建新线程

() -> {...} - Lambda表达式定义线程任务

"生产者" + i - 线程命名

.start() - 启动线程

这里通过循环来创建线程，所以用循环的参数为其命名

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75


 public static void main(String[] args) throws InterruptedException {
 MessageQueue queue = new MessageQueue(2);

 // 三个生产者向队列里存值
 for (int i = 0; i < 3; i++) {
 int id = i;
 new Thread(() -> {
 queue.put(new Message(id, "值" + id));
 }, "生产者" + i).start();
 }

 Thread.sleep(1000);

 // 一个消费者不停的从队列里取值
 new Thread(() -> {
 while (true) {
 queue.take();
 }
 }, "消费者").start();

 }
}

// 消息队列被生产者和消费者持有
class MessageQueue {
 private LinkedList<Message> list = new LinkedList<>();

 // 容量
 private int capacity;

 public MessageQueue(int capacity) {
 this.capacity = capacity;
 }
 //生产者
 public void put(Message message) {
 synchronized (list) {
 while (list.size() == capacity) {
 log.info("队列已满，生产者等待");
 try {
 list.wait();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 list.addLast(message);
 log.info("生产消息:{}", message);
 // 生产后通知消费者
 list.notifyAll();
 }
 }
 //消费者
 public Message take() {
 synchronized (list) {
 while (list.isEmpty()) {
 log.info("队列已空，消费者等待");
 try {
 list.wait();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 Message message = list.removeFirst();
 //从队列头部取出消息
 log.info("消费消息:{}", message);
 // 消费后通知生产者
 list.notifyAll();
 return message;
 }
 }
}
 // 消息
class Message {
 private int id;
 private Object value;
}

主函数:

创建了一个容量为2的消息队列MessageQueue
启动3个生产者线程，每个生产者向队列中放入一条消息
主线程休眠1秒，让生产者有足够时间开始工作
启动一个消费者线程，不断从队列中取出消息

生产者:

使用synchronized块获取list对象的锁
检查队列是否已满（while循环防止虚假唤醒）
如果队列已满，调用wait()释放锁并等待
当队列有空闲时，添加消息到队列尾部
调用notifyAll()唤醒可能正在等待的消费者线程

消费者:

使用synchronized块获取list对象的锁
检查队列是否为空（while循环防止虚假唤醒）
如果队列为空，调用wait()释放锁并等待
当队列有消息时，从队列头部取出消息
调用notifyAll()唤醒可能正在等待的生产者线程
返回取出的消息

小结

同步机制：使用synchronized保证对队列操作的原子性
等待/通知机制：使用wait()和notifyAll()实现线程间通信
循环检查条件：使用while而非if检查条件，防止虚假唤醒
容量限制：控制队列大小，防止内存耗尽

可重入锁

从Java 5开始，引入了一个高级的处理并发的java.util.concurrent包，它提供了大量更高级的并发功能，能大大简化多线程程序的编写。

我们知道Java语言直接提供了synchronized关键字用于加锁，但这种锁一是很重，二是获取时必须一直等待，没有额外的尝试机制。

java.util.concurrent.locks包提供的ReentrantLock用于替代synchronized加锁，我们来看一下传统的synchronized代码：

1
2
3
4
5
6
7
8
9


public class Counter {
 private int count;

 public void add(int n) {
 synchronized(this) {
 count += n;
 }
 }
}

如果用ReentrantLock替代，可以把代码改造为：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


public class Counter {
 private final Lock lock = new ReentrantLock();
 private int count;

 public void add(int n) {
 lock.lock();
 try {
 count += n;
 } finally {
 lock.unlock();
 }
 }
}

因为synchronized是Java语言层面提供的语法，所以我们不需要考虑异常，而ReentrantLock是Java代码实现的锁，我们就必须先获取锁，然后在finally中正确释放锁。

顾名思义，ReentrantLock是可重入锁，它和synchronized一样，一个线程可以多次获取同一个锁。

和synchronized不同的是，ReentrantLock可以尝试获取锁：

1
2
3
4
5
6
7


if (lock.tryLock(1, TimeUnit.SECONDS)) {
 try {
 ...
 } finally {
 lock.unlock();
 }
}

上述代码在尝试获取锁的时候，最多等待1秒。如果1秒后仍未获取到锁，tryLock()返回false，程序就可以做一些额外处理，而不是无限等待下去。

所以，使用ReentrantLock比直接使用synchronized更安全，线程在tryLock()失败的时候不会导致死锁。

下面来介绍一下它的各种方法，以及一个较复杂的案例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


// 默认非公平锁，参数传true 表示未公平锁
ReentrantLock lock = new ReentrantLock(false);
// 尝试获取锁
lock()
// 释放锁 应放在finally块中 必须执行到
unlock()
try {
 // 获取锁时可被打断,阻塞中的线程可被打断
 LOCK.lockInterruptibly();
} catch (InterruptedException e) {
 return;
}
// 尝试获取锁 获取不到就返回false
LOCK.tryLock()
// 支持超时时间 一段时间没获取到就返回false
tryLock(long timeout, TimeUnit unit)
// 指定条件变量 休息室 一个锁可以创建多个休息室
Condition waitSet = ROOM.newCondition();
// 释放锁 进入waitSet等待 释放后其他线程可以抢锁
yanWaitSet.await()
// 唤醒具体休息室的线程 唤醒后 重写竞争锁
yanWaitSet.signal()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67


 public static void main(String[] args) {
 AwaitSignal awaitSignal = new AwaitSignal(5);
 // 构建三个条件变量
 Condition a = awaitSignal.newCondition();
 Condition b = awaitSignal.newCondition();
 Condition c = awaitSignal.newCondition();
 // 开启三个线程
 new Thread(() -> {
 awaitSignal.print("a", a, b);
 }).start();

 new Thread(() -> {
 awaitSignal.print("b", b, c);
 }).start();

 new Thread(() -> {
 awaitSignal.print("c", c, a);
 }).start();

 try {
 Thread.sleep(1000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 awaitSignal.lock();
 try {
 // 先唤醒a
 a.signal();
 } finally {
 awaitSignal.unlock();
 }
 }

}

class AwaitSignal extends ReentrantLock {

 // 循环次数
 private int loopNumber;

 public AwaitSignal(int loopNumber) {
 this.loopNumber = loopNumber;
 }

 /**
 * @param print 输出的字符
 * @param current 当前条件变量
 * @param next 下一个条件变量
 */
 public void print(String print, Condition current, Condition next) {

 for (int i = 0; i < loopNumber; i++) {
 lock();
 try {
 try {
 // 获取锁之后等待
 current.await();
 System.out.print(print);
 } catch (InterruptedException e) {
 
 }
 next.signal();
 } finally {
 unlock();
 }
 }
 }

流程分析：

初始化 ：
主线程创建了 AwaitSignal 对象，设置循环次数为 5。
创建了三个 Condition 对象：a、b、c，分别对应三个线程。
三个线程启动，分别调用 print("a", a, b) 、 print("b", b, c) 、 print("c", c, a) 。
主线程休眠 1 秒后，获取锁并通过 a.signal() 唤醒线程 A。
线程启动后 ：
每个线程进入 print 方法，执行 lock() 获取锁。由于 ReentrantLock 是互斥锁，同一时刻只有一个线程能持有锁。
假设线程 A 先获取锁，它调用 a.await() ，释放锁并进入等待状态（等待 Condition a 的信号）。
其他线程（B 和 C）尝试 lock() ，但锁被占用，它们会阻塞在 lock() 上。
主线程唤醒线程A ：
主线程在 try { Thread.sleep(1000); } 后执行 awaitSignal.lock() ，获取锁。
调用 a.signal() ，唤醒等待在 Condition a 上的线程 A。
主线程执行 unlock() ，释放锁。
线程A被唤醒后 ：
线程 A 从 a.await() 返回，但它需要重新获取锁才能继续执行。
因为主线程已经释放锁（ unlock() ），线程 A 成功重新获取锁。
线程 A 打印 “a”，然后调用 b.signal() 唤醒线程 B。
线程 A 执行 unlock() ，释放锁。
线程B被唤醒后 ：
线程 B 在 b.await() 上等待，收到 b.signal() 后被唤醒。
线程 B 尝试重新获取锁。由于线程 A 已释放锁，线程 B 获取锁成功。
线程 B 打印 “b”，调用 c.signal() 唤醒线程 C，然后释放锁。

小结

ReentrantLock可以替代synchronized进行同步；

ReentrantLock获取锁更安全；

必须先获取到锁，再进入try {...}代码块，最后使用finally保证释放锁；

可以使用tryLock()尝试获取锁。

线程池

（线程池感觉都写的不是很明白）

Java语言虽然内置了多线程支持，启动一个新线程非常方便，但是，创建线程需要操作系统资源（线程资源，栈空间等），频繁创建和销毁大量线程需要消耗大量时间。

如果可以复用一组线程：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


┌─────┐ execute ┌──────────────────┐
│Task1│─────────▶│ThreadPool │
├─────┤ │┌───────┐┌───────┐│
│Task2│ ││Thread1││Thread2││
├─────┤ │└───────┘└───────┘│
│Task3│ │┌───────┐┌───────┐│
├─────┤ ││Thread3││Thread4││
│Task4│ │└───────┘└───────┘│
├─────┤ └──────────────────┘
│Task5│
├─────┤
│Task6│
└─────┘
 ...

那么我们就可以把很多小任务让一组线程来执行，而不是一个任务对应一个新线程。这种能接收大量小任务并进行分发处理的就是线程池。

简单地说，线程池内部维护了若干个线程，没有任务的时候，这些线程都处于等待状态。如果有新任务，就分配一个空闲线程执行。如果所有线程都处于忙碌状态，新任务要么放入队列等待，要么增加一个新线程进行处理。

Java标准库提供了ExecutorService接口表示线程池，它的典型用法如下：

1
2
3
4
5
6
7
8


// 创建固定大小的线程池:
ExecutorService executor = Executors.newFixedThreadPool(3);
// 提交任务:
executor.submit(task1);
executor.submit(task2);
executor.submit(task3);
executor.submit(task4);
executor.submit(task5);

因为ExecutorService只是接口，Java标准库提供的几个常用实现类有：

FixedThreadPool：线程数固定的线程池；
CachedThreadPool：线程数根据任务动态调整的线程池；
SingleThreadExecutor：仅单线程执行的线程池。

创建这些线程池的方法都被封装到Executors这个类中。我们以FixedThreadPool为例，看看线程池的执行逻辑：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


// thread-pool
import java.util.concurrent.*;

public class Main {
 public static void main(String[] args) {
 // 创建一个固定大小的线程池:
 ExecutorService es = Executors.newFixedThreadPool(4);
 for (int i = 0; i < 6; i++) {
 es.submit(new Task("" + i));
 }
 // 关闭线程池:
 es.shutdown();
 }
}

class Task implements Runnable {
 private final String name;

 public Task(String name) {
 this.name = name;
 }

 @Override
 public void run() {
 System.out.println("start task " + name);
 try {
 Thread.sleep(1000);
 } catch (InterruptedException e) {
 }
 System.out.println("end task " + name);
 }
}

我们观察执行结果，一次性放入6个任务，由于线程池只有固定的4个线程，因此，前4个任务会同时执行，等到有线程空闲后，才会执行后面的两个任务。

线程池在程序结束的时候要关闭。使用shutdown()方法关闭线程池的时候，它会等待正在执行的任务先完成，然后再关闭。shutdownNow()会立刻停止正在执行的任务，awaitTermination()则会等待指定的时间让线程池关闭。

如果我们把线程池改为CachedThreadPool，由于这个线程池的实现会根据任务数量动态调整线程池的大小，所以6个任务可一次性全部同时执行。

如果我们想把线程池的大小限制在4～10个之间动态调整怎么办？我们查看Executors.newCachedThreadPool()方法的源码：

1
2
3
4
5
6


public static ExecutorService newCachedThreadPool() {
 return new ThreadPoolExecutor(
 0, Integer.MAX_VALUE,
 60L, TimeUnit.SECONDS,
 new SynchronousQueue<Runnable>());
}

因此，想创建指定动态范围的线程池，可以这么写：

1
2
3
4
5
6


int min = 4;
int max = 10;
ExecutorService es = new ThreadPoolExecutor(
 min, max,
 60L, TimeUnit.SECONDS,
 new SynchronousQueue<Runnable>());

ScheduledThreadPool

还有一种任务，需要定期反复执行，例如，每秒刷新证券价格。这种任务本身固定，需要反复执行的，可以使用ScheduledThreadPool。放入ScheduledThreadPool的任务可以定期反复执行。

创建一个ScheduledThreadPool仍然是通过Executors类：

1

ScheduledExecutorService ses = Executors.newScheduledThreadPool(4);

我们可以提交一次性任务，它会在指定延迟后只执行一次：

1
2


// 1秒后执行一次性任务:
ses.schedule(new Task("one-time"), 1, TimeUnit.SECONDS);

如果任务以固定的每3秒执行，我们可以这样写：

1
2


// 2秒后开始执行定时任务，每3秒执行:
ses.scheduleAtFixedRate(new Task("fixed-rate"), 2, 3, TimeUnit.SECONDS);

如果任务以固定的3秒为间隔执行，我们可以这样写：

1
2


// 2秒后开始执行定时任务，以3秒为间隔执行:
ses.scheduleWithFixedDelay(new Task("fixed-delay"), 2, 3, TimeUnit.SECONDS);

注意FixedRate和FixedDelay的区别。FixedRate是指任务总是以固定时间间隔触发，不管任务执行多长时间：

1
2
3


│░░░░ │░░░░░░ │░░░ │░░░░░ │░░░ 
├───────┼───────┼───────┼───────┼────▶
│◀─────▶│◀─────▶│◀─────▶│◀─────▶│

而FixedDelay是指，上一次任务执行完毕后，等待固定的时间间隔，再执行下一次任务：

1
2
3


│░░░│ │░░░░░│ │░░│ │░
└───┼───────┼─────┼───────┼──┼───────┼──▶
 │◀─────▶│ │◀─────▶│ │◀─────▶│

因此，使用ScheduledThreadPool时，我们要根据需要选择执行一次、FixedRate执行还是FixedDelay执行。

还可以思考下面的问题：

在FixedRate模式下，假设每秒触发，如果某次任务执行时间超过1秒，后续任务会不会并发执行？
如果任务抛出了异常，后续任务是否继续执行？

Java标准库还提供了一个java.util.Timer类，这个类也可以定期执行任务，但是，一个Timer会对应一个Thread，所以，一个Timer只能定期执行一个任务，多个定时任务必须启动多个Timer，而一个ScheduledThreadPool就可以调度多个定时任务，所以，我们完全可以用ScheduledThreadPool取代旧的Timer。

小结

JDK提供了ExecutorService实现了线程池功能：

线程池内部维护一组线程，可以高效执行大量小任务；
Executors提供了静态方法创建不同类型的ExecutorService；
必须调用shutdown()关闭ExecutorService；
ScheduledThreadPool可以定期调度多个任务。

并发 on 边个濑椰的博客

Java 多线程

参考网站

Java 多线程

进程/线程

多线程

创建多线程

线程的优先级

小结

线程的阻塞

Thread.sleep()

Thread.join()

小结

中断线程

Thread.interrupt

running标志位

volatile 的用处

小结

线程状态

系统 - 五种状态

Java - 六种状态

Thread类中的核心方法

守护线程

小结

线程同步

synchronized 同步锁

不需要 synchronized 的操作

不可变对象无需同步

小结

线程同步方法

线程安全

synchronized 修饰

小结

死锁

可重入锁

死锁

小结

线程通信

wait()

notify()

小结

生产者消费者模型

示例分析

小结

可重入锁

小结

线程池

ScheduledThreadPool

小结

`Thread.sleep()`

`Thread.join()`

`Thread.interrupt`

`running`标志位

`volatile` 的用处

`synchronized 同步锁`

不需要 `synchronized` 的操作

`synchronized` 修饰

`wait()`

`notify()`