第03篇_并发编程

第01章_多线程开发

第一节 线程基础

1. 线程简介

1) 什么是线程？

线程是CPU调度和执行的最小单位，线程之间共享进程的堆和方法区(元空间)，但是有各自的方法栈和程序计数器等，适合任务协作和高并发性能的场景。

• 优点：多线程可提高IO密集型应用的执行效率，提升GUI程序的响应性等。
• 缺点：提升了编码复杂性，可能带来线程安全问题或死锁等。

注意：

1. 进程是操作系统分配资源的最小单位，在启动Java应用时，就是启动了一个JVM进程，它包括主线程(main)和其它线程。

2) 线程的六大状态

在 Java 中，线程状态被定义为枚举类：Thread.State，有如下六种状态（JVM不区分Running和Ready）：

注意：

1. RUNNABLE不代表CPU一定在执行该线程的代码，也可能在等待操作系统分配时间片，只是它没有在等待其他条件。
2. 在操作系统中，其实只有五种状态，其中Running根据是否在运行拆分出就绪态Ready，但三个阻塞/等待状态不做区分。

2. 创建和启动线程

1) 直接创建Thread

可以通过继承java.lang.Thread类，重写其run方法来直接定义一个线程。

xxxxxxxxxx
14
1
// 1. 继承Thread类
2
public class HelloThread extends Thread {
3

4
    // 2. 重写run方法：线程入口，无参无返回值，不能抛出受检异常
5
    @Override
6
    public void run() {
7
        System.out.println("hello");
8
    }
9
}
10

11
public static void main(String[] args) {
12
    Thread thread = new HelloThread(); // 3. 创建线程对象
13
    thread.start(); // 4. 启动线程，分配程序计数器、栈等线程资源
14
}

注意：

1. 此种方式存在单继承问题，不推荐使用。

2) 定义Runable实现类

由于Java只支持单继承，因此一般都是定义java.lang.Runnable接口的实现类，然后创建Runnable的对象传给Thread对象去执行。

xxxxxxxxxx
14
1
// 1. 实现Runnable接口
2
public class HelloRunnable implements Runnable {
3

4
    // 2. 重写run方法，该方法将优先于Thread的run方法进行调用
5
    @Override
6
    public void run() {
7
        System.out.println("hello");
8
    }
9
}
10

11
public static void main(String[] args) {
12
    Thread helloThread = new Thread(new HelloRunnable()); // 3. 创建Thread对象，并传递一个Runnable对象
13
    helloThread.start(); // 4. 启动线程
14
}

注意：

1. 一定要通过 start 方法启动线程，如果使用 run 方法启动，将会在当前线程执行。

3) 定义Callable+FutureTask实现类

java.lang.Callable一般用于有返回结果的同步非阻塞的执行方法，需要使用FutureTask包装后执行：

xxxxxxxxxx
29
1
public class MiTest {
2

3
    public static void main(String[] args) throws ExecutionException, InterruptedException {
4
        //1. 创建MyCallable
5
        MyCallable myCallable = new MyCallable();
6
        //2. 创建FutureTask，传入Callable
7
        FutureTask futureTask = new FutureTask(myCallable);
8
        //3. 创建Thread线程
9
        Thread t1 = new Thread(futureTask);
10
        //4. 启动线程
11
        t1.start();
12
        //5. 非阻塞式的做一些操作
13
        //6. 同步要结果
14
        Object count = futureTask.get();
15
        System.out.println("总和为：" + count);
16
    }
17
}
18

19
class MyCallable implements Callable{
20

21
    @Override
22
    public Object call() throws Exception {
23
        int count = 0;
24
        for (int i = 0; i < 100; i++) {
25
            count += i;
26
        }
27
        return count;
28
    }
29
}

3. 线程的相关操作

1) 线程的基本属性

xxxxxxxxxx
22
1
// 1. 当前线程
2
public static native Thread currentThread(); // Thread类静态方法
3

4
// 2. 线程ID和名称
5
public long getId(); // 线程ID，一个递增的整数，每创建一个线程就加一
6
public final String getName(); // 线程名称，默认值是"Thread-"后跟一个编号
7
public final synchronized void setName(String name) // 设置线程名称(也可以在创建Thread对象时指定)
8
    
9
// 3. 线程优先级
10
public final int getPriority() // 获取线程优先级，从1~10，默认为5
11
public final void setPriority(int newPriority) // 设置线程优先级，映射到不同操作系统优先级上(仅供提示)
12
    
13
// 4. 线程状态
14
public State getState() // 获取线程状态
15
    
16
// 5. 线程存活状态
17
public final native boolean isAlive() // 线程只有在NEW和TERMINATED状态才为false，其它都为true
18

19
// 6. 是否为守护线程(daemo线程，即其它线程的辅助线程，如垃圾回收线程等，当整个程序只剩下daemo线程时，程序就会退出。）
20
public final boolean isDaemon() // 是否为守护线程，默认为false
21
public final void setDaemon(boolean on) // 设置为守护线程
22

2) 线程的常用方法

xxxxxxxxxx
22
1
// 1. 睡眠指定毫秒
2
// 时间有一定的偏差，在睡眠期间，会让出CPU，可以被其他线程中断(中断后抛出InterruptedException)
3
public static native void sleep(long millis) throws InterruptedException; // Thread的静态方法
4

5
// 2. 让出CPU(Runable->Ready状态，仅供建议，且只作用于当前线程)
6
public static native void yield(); // Thread的静态方法
7

8
// 3. 等待该线程结束。转为WAIT/TIMED_WAITING状态，等待期间可以被其他线程中断
9
public final void join() throws InterruptedException // 内部调用了join(0)
10
public final synchronized void join(long millis) throws InterruptedException 
11

12
// 4. 一些过时的方法，不应该去使用。
13
public final void stop()
14
public final void suspend()
15
public final void resume()
16
    
17
// 示例1：主线程等待thread线程，先不要退出
18
public static void main(String[] args) throws InterruptedException {
19
    Thread thread = new HelloThread();
20
    thread.start();
21
    thread.join();
22
}     

注意：

1. wait() 是对象级别的方法，定义在 Object 类，用于线程间的协作，需要在同步代码块中调用，会释放对象锁。
2. join() 是线程级别的方法，定义在 Thread 类，用于线程的同步，不会释放锁，用于等待目标线程执行完成。

4. 线程的结束方式

1) 正常/异常返回

正常/异常返回就是让线程的run方法结束，无论是return结束，还是抛出异常结束，都可以。

一般而言，对于以线程提供服务的程序模块，它应该封装取消或关闭的操作，让调用者能正确关闭线程。

xxxxxxxxxx
6
1
// Future接口提供了如下方法以取消任务
2
boolean cancel(boolean mayInterruptIfRunning);
3

4
// ExecutorService提供了如下两个关闭方法
5
void shutdown();
6
List<Runnable> shutdownNow();

2) 调用stop强制停止

强制让线程结束，无论你在干嘛，不推荐使用此种方式，但是，他确实可以把线程干掉。

xxxxxxxxxx
13
1
public static void main(String[] args) throws InterruptedException {
2
    Thread t1 = new Thread(() -> {
3
        try {
4
            Thread.sleep(5000);
5
        } catch (InterruptedException e) {
6
            e.printStackTrace();
7
        }
8
    });
9
    t1.start();
10
    Thread.sleep(500);
11
    t1.stop(); // 停止t1线程
12
    System.out.println(t1.getState());
13
}

3) 线程中断

线程中断是一种协作机制，通过给线程传递一个取消信号，由线程来决定如何以及何时退出，并不是强迫终止一个线程。

每个线程都有一个中断标志位，表示该线程是否被中断，可通过如下方式获取和设置：

xxxxxxxxxx
7
1
// 1. Thread类的实例方法(操作目标线程)
2
public boolean isInterrupted() // 获取线程是否被中断，即获取中断标志位
3
public void interrupt() // 中断该线程，即设置中断标志位为true
4

5
// 2. Thread类的静态方法(操作当前线程)
6
// 注意：此操作也会同时清空中断标志位，以方便后续处理!!!
7
public static boolean interrupted() // 检查当前线程是否被中断(设置了中断标识位)

线程处于不同状态时，对中断方法的响应也会有所区别：

• 等待类状态（WAITING/TIMED_WAITING）：会唤醒线程并抛 InterruptedException，同时清除中断标志；
• RUNNABLE 状态：仅设置中断标志位，需线程主动检测才能响应；
• NEW/TERMINATED 状态：中断无任何效果，信号被忽略；
• BLOCKED 状态（synchronized 锁阻塞）：不响应中断，线程继续等待锁；
• 特殊情况（LockSupport.park()）：中断会唤醒线程并设置标志位，不抛异常。

5. 面试扩展

1) 并行 vs 并发

• 并行：两个及两个以上的作业在同一 时间段 内执行。
• 并发：两个及两个以上的作业在同一 时刻执行，多核CPU才可能并发，并发是并行的一个特例。

2) 阻塞 vs 非阻塞

主要取决于等待时能做别的吗，阻塞是 “等待时躺平”，资源被占用且无法复用，非阻塞是 “等待时摸鱼”，资源可高效利用：

• 阻塞：等待任务期间，当前线程 / 进程无法做任何事，只能闲置等待。
• 非阻塞：等待任务期间，当前线程 / 进程可继续处理其他任务，不用闲置。

3) 同步 vs 异步

主要取决于任务结果怎么通知，同步是 “主动等结果”，全程不脱离任务流程，异步是 “被动收通知”，发起后即可脱离任务流程：

• 同步：发起任务后，必须等待任务完全完成，才能继续做下一件事，结果实时获取。
• 异步：发起任务后，不用等待，直接去做其他事；任务完成后，会通过回调、通知等方式告知结果。

同步非阻塞与异步非阻塞的区别？

答：非阻塞指调用后立即返回，无需等待，同步还是异步取决于主动检查结果还是通过回调处理结果。

第二节 线程同步

1. 线程并发问题

1) 有序性

有序性指指令的执行顺序和编写顺序是否一致，在JIT编译和CPU执行层面，都可能会对指令进行重排序操作，以优化执行效率。

• 指令重排序操作只保证单线程下的执行逻辑一致（as-if-serial语义+happens-before原则），多线程下可能存在并发问题。
• 在Java中，对共享变量添加volatile 修饰，即可禁止指令重排序，其底层是基于内存屏障(mfence)实现的。

2) 可见性

可见性指一个线程对共享变量做了修改，其它线程是否可以立即看到修改后的值。

• 可见性问题主要是由于JMM的本地内存和CPU一级/二级缓存造成的，修改后的数据未及时写回主内存中。
• 在Java中，对共享变量添加volatile 修饰，也可以解决可见性问题。

注意：

1. 在 Intel CPU 缓存层面，有一个MESI协议，标识缓存的修改状态，可以保证CPU缓存一致性问题。
2. 但注意写缓冲器和无效化队列会对其进行破坏，部分情形需结合性能稍低的总线锁来保证。
3. 伪共享：CPU缓存是按行加载的，如果不同CPU加载了同一个缓存行，分别对该行的X和Y变量进行修改，会导致缓存频繁失效。

3) 原子性

原子性指多次操作要么全都执行，要么全都不执行，不会受任何因素而中断。

• 在Java中，原子性问题可通过CAS、synchronized、Lock等方式解决。

2. synchronized

1) synchronized简介

synchronized是 Java 内置的 线程同步关键字，用于保证多线程环境下共享资源的安全访问，核心特性如下：

• 原子性：被修饰的代码块 / 方法会被当作一个 “整体” 执行，要么全部完成，要么全部不执行，不会被其他线程打断；
• 可见性：线程释放锁时，会将修改后的共享变量值同步到主内存；其他线程获取锁时，会从主内存读取最新值。
• 有序性：禁止指令重排序，确保代码执行顺序和编写顺序一致，避免多线程下的逻辑混乱；
• 非公平锁：默认不保证等待线程的获取顺序，谁先抢到锁谁执行，优点是效率高。
• 可重入性：内部会记录持有锁的线程和重入数，支持某个线程多次获取和释放锁。

注意：

1. 在等待synchronized锁时，进入锁对象的锁等待队列，线程状态为BLOCK状态，此时无法响应中断。

2) 基本使用

修饰实例方法

修饰实例方法，对 this对象 进行加锁：

xxxxxxxxxx
14
1
// 
2
public class Counter {
3
    private int count; // 共享变量
4

5
    // synchronized
6
    public synchronized void incr() {
7
        count++;
8
    }
9

10
    // synchronized
11
    public synchronized int getCount() {
12
        return count;
13
    }
14
}

注意：

1. 特别注意，同一个对象的不同synchronized方法不能同时执行，但不同对象的同一synchronized方法能够同时执行。
2. 无法修饰构造方法，因为不可能多个线程同时调用同一个对象的构造方法，如需加锁，需在内部使用静态代码块。

修饰静态方法

修饰静态方法，对 类对象(StaticCounter.class) 进行加锁：

xxxxxxxxxx
11
1
public class StaticCounter {
2
    private static int count = 0; // 共享变量
3

4
    public static synchronized void incr() {
5
        count++;
6
    }
7

8
    public static synchronized int getCount() {
9
        return count;
10
    }
11
}

注意：

1. 同一个对象的静态synchronized方法和实例synchronized方法修饰的是不同对象，可以同时执行。

修饰代码块

修饰代码块，对 指定对象 进行加锁：

xxxxxxxxxx
16
1
public class Counter {
2
    private int count; // 共享变量
3
    private Object lock = new Object(); // 锁对象(lock也可以是this或类对象)
4
    
5
    public void incr(){
6
        synchronized(lock){ 
7
            count ++;    
8
        }
9
    }
10
    
11
    public int getCount() {
12
        synchronized(lock){
13
            return count;
14
        }
15
    }
16
} 

注意：

1. 指定的对象不能为null，否则会抛 NullPointerException。
2. 尽量不要使用包装类或字符串作为锁对象，因为它们有缓存池或常量池，锁对象粒度会过大。

3) 实现原理

在Java的对象头中，有一个64位的MarkWord字段，用于记录 synchronized锁的四种状态变化：

在升级到重量级锁后，调用的是C++编写的ObjectMonitor.hpp代码：https://hg.openjdk.org/jdk8u/jdk8u/hotspot/file/69087d08d473/src/share/vm/runtime/objectMonitor.cpp

4) 扩展知识

• 锁消除：如果不存在操作临界资源的情况，会触发锁消除，你即便写了synchronized，它也不会触发。

  xxxxxxxxxx
  4
  1
  public synchronized void method(){
  2
      // 没有操作临界资源
  3
      // 此时这个方法的synchronized你可以认为木有~~
  4
  }
  

• 锁膨胀：在循环中频繁的获取和释放锁资源时，会带来很大的消耗，此时可能会将锁膨胀到循环之外。

  xxxxxxxxxx
  13
  1
  public void method(){
  2
      for(int i = 0;i < 999999;i++){
  3
          synchronized(对象){
  4
  
  5
          }
  6
      }
  7
      // 这是上面的代码会触发锁膨胀
  8
      synchronized(对象){
  9
          for(int i = 0;i < 999999;i++){
  10
  
  11
          }
  12
      }
  13
  }
  

• 锁升级：

  • 同步对象初始是无锁状态，当一个线程访问同步块并获取锁时，会升级为偏向锁（该锁在高版本JDK已被禁用）。

  • 当其它线程也试图访问该对象时，偏向锁会升级为轻量级锁，获取到锁的线程执行，其它线程进行自旋。

  • 当锁竞争加剧时，自旋会大量消耗CPU资源，此时会升级为重量级锁，获取到锁的线程执行，其它线程阻塞等待。

    

3. wait/notify

1) wait/notify简介

在Java中，任意对象都可以参与线程协作，它们都有wait和notify方法，可以在synchronized代码块中调用：

• 在调用wait方法后，当前线程状态变为WAITING/TIMED_WAITING，进入锁对象的条件等待队列。
• 当被其它线程notify方法唤醒后，需重新竞争锁，如果获取到锁，线程状态变为RUNNABLE，并从wait调用中返回。
• 如果未获取到锁，将会进入锁对象的锁等待队列，线程状态变为BLOCKED，直到获得锁后才能从wait调用返回。

xxxxxxxxxx
8
1
// 1. wait
2
public final void wait() throws InterruptedException // 无限期等待，等同wait(0)
3
public final native void wait(long timeout) throws InterruptedException // 超时等待，timeout表示等待时间，单位为毫秒
4

5
// 2. notify
6
public final native void notify(); // 通知，从条件队列中选一个线程，将其从队列中移除并唤醒
7
public final native void notifyAll(); // 通知所有，移除条件队列中所有的线程并全部唤醒
8

特别注意，从wait返回后，不一定表示等待的条件就满足了，仍需进行条件检查，因此，wait方法的一般调用模式为：

xxxxxxxxxx
7
1
synchronized (obj) {
2
    // 循环检查条件是否满足
3
    while (!条件成立)
4
        obj.wait(); // 不满足则释放锁，进入等待
5
    
6
    // 执行条件满足后的操作
7
}

注意：

1. 并非调用notify方法后就立即释放锁，而是等到当前synchronized代码块执行完毕后才会释放，其它线程才可能获取到锁。
2. wait/notify 机制只支持一个条件队列，如果有多个等待条件，只能共用，并且在通知时必须通知所有等待的线程。
3. 线程对象的join方法是基于wait方法实现的，当子线程运行结束时，由 JVM 调用notifyAll来通知。

2) 生产者/消费者模型

生产者线程和消费者线程通过共享队列进行协作，生产者将数据或任务放到队列上，而消费者从队列上取数据或任务。如果队列长度有限，在队列满的时候，生产者需要等待，而在队列为空的时候，消费者需要等待。

它们协作的共享变量是队列，我们将队列作为单独的类进行设计，代码如下：

xxxxxxxxxx
28
1
static class MyBlockingQueue<E> {
2
    private Queue<E> queue = null; // 1. 共享变量：队列
3
    private int limit; // 队列上限
4

5
    public MyBlockingQueue(int limit) {
6
        this.limit = limit;
7
        queue = new ArrayDeque<>(limit);
8
    }
9

10
    // 2. 生产者调用，放数据，如果满了则等待
11
    public synchronized void put(E e) throws InterruptedException {
12
        while (queue.size() == limit) {
13
            wait(); // 等待(注意，锁对象为this)
14
        }
15
        queue.add(e);
16
        notifyAll(); // 4. 生产数据后可通知消费者“有数据了”！(注意：这里只能通知所有线程)
17
    }
18

19
    // 3. 消费者调用，拿数据，空了也等待
20
    public synchronized E take() throws InterruptedException {
21
        while (queue.isEmpty()) {
22
            wait();
23
        }
24
        E e = queue.poll();
25
        notifyAll(); // 5. 拿走数据后可通知生产者“有空位了”(注意：这里只能通知所有线程)
26
        return e;
27
    }
28
}

在上面代码中，生产者和消费者都调用了wait方法，但它们等待的条件是不一样的。生产者在队列为满时等待，而消费者在队列为空的时候等待，它们等待条件不同但又使用相同的条件队列，所以要调用notifyAll而不能调用notify，因为notify可能唤醒的恰好是同类线程。

类似的，它们也都调用了notifyAll方法，但是需满足的条件也不一致，生产者在“有数据了”的条件下通知消费者，消费者在“有空位了”的条件下通知生产者。

3) 同时开始模型

在运动员比赛中，听到比赛开始枪响后同时开始，在一些程序，尤其是模拟仿真程序中，要求多个线程能同时开始。

它们协作的共享变量是一个开始信号，我们用一个类FireFlag来表示这个协作对象：

xxxxxxxxxx
16
1
static class FireFlag {
2
    private volatile boolean fired = false; // 1. 共享变量：是否开始
3

4
    // 2. 子线程在启动后调用，等待开始
5
    public synchronized void waitForFire() throws InterruptedException {
6
        while (!fired) {
7
            wait(); // 等待(注意，锁对象为this)
8
        }
9
    }
10

11
    // 3. 主线程调用，发起开始指令
12
    public synchronized void fire() {
13
        this.fired = true; 
14
        notifyAll(); // 通知所有wait的线程
15
    }
16
}

子线程应该调用waitForFire()等待枪响，而主线程应该调用fire()发射比赛开始信号，代码如下：

xxxxxxxxxx
34
1
// 子线程
2
static class Racer extends Thread {
3
    FireFlag fireFlag; // 1. 共享变量
4

5
    public Racer(FireFlag fireFlag) {
6
        this.fireFlag = fireFlag;
7
    }
8

9
    @Override
10
    public void run() {
11
        try {
12
            // 2. 等待开始
13
            this.fireFlag.waitForFire();
14
            System.out.println("start run " + Thread.currentThread().getName());
15
        } catch (InterruptedException e) {
16
        }
17
    }
18
}
19

20
// 主线程
21
public static void main(String[] args) throws InterruptedException {
22
    // 1. 启动20个子线程
23
    int num = 10;
24
    FireFlag fireFlag = new FireFlag();
25
    Thread[] racers = new Thread[num];
26
    for (int i = 0; i < num; i++) {
27
        racers[i] = new Racer(fireFlag);
28
        racers[i].start();
29
    }
30
    Thread.sleep(1000);
31
    
32
    // 2. 开始
33
    fireFlag.fire(); 
34
}

4) 等待结束模型

主线程将任务分解为若干个子任务，为每个子任务创建一个线程，主线程在继续执行其他任务之前需要等待每个子任务执行完毕。

主线程与各个子线程协作的共享变量是一个数，这个数表示未结束线程个数，代码如下：

xxxxxxxxxx
22
1
public class MyLatch {
2
    private int count; // 1. 共享变量
3

4
    public MyLatch(int count) {
5
        this.count = count; // 初始化为子线程个数
6
    }
7

8
    // 2. 主线程调用，等待所有子线程结束
9
    public synchronized void await() throws InterruptedException {
10
        while (count > 0) {
11
            wait();
12
        }
13
    }
14

15
    // 3. 子线程在退出前调用，线程计数 - 1
16
    public synchronized void countDown() {
17
        count--;
18
        if (count <= 0) {
19
            notifyAll();
20
        }
21
    }
22
}

应用代码示例如下：

xxxxxxxxxx
38
1
// 子线程
2
static class Worker extends Thread {
3
    MyLatch latch;
4

5
    public Worker(MyLatch latch) {
6
        this.latch = latch;
7
    }
8

9
    @Override
10
    public void run() {
11
        try {
12
            // 1. 执行业务
13
            Thread.sleep((int) (Math.random() * 1000));
14

15
            // 2. 结束前调用countDown，线程计数-1
16
            this.latch.countDown(); 
17
        } catch (InterruptedException e) {
18
        }
19
    }
20
}
21

22
// 主线程
23
public static void main(String[] args) throws InterruptedException {
24
    // 1. 初始化计数
25
    int workerNum = 100;
26
    MyLatch latch = new MyLatch(workerNum); 
27
    
28
    // 2. 启动100个线程
29
    Worker[] workers = new Worker[workerNum];
30
    for (int i = 0; i < workerNum; i++) {
31
        workers[i] = new Worker(latch);
32
        workers[i].start();
33
    }
34
    
35
    // 3. 等待子线程都结束
36
    latch.await(); 
37
    System.out.println("collect worker results");
38
}

注意：

1. 可将线程计数初始值设置为1，由子线程调用await()，主线程调用countDown()，还可实现上面的“同时开始”模式。

4) 集合点模型

在并行迭代计算中，每个线程负责一部分计算，然后在集合点等待其他线程完成，所有线程到齐后，交换数据和计算结果，再进行下一次迭代。

它们协作的共享变量依然是一个数，这个数表示未到集合点的线程个数。

xxxxxxxxxx
28
1
// CyclicBarrier
2
public class AssemblePoint {
3
    private int n; // 1. 共享变量
4

5
    public AssemblePoint(int n) {
6
        this.n = n;
7
    }
8

9
    // 2. 集合，线程达到集合点时调用，等待其它未到的线程。
10
    public synchronized void await() throws InterruptedException {
11
        // 2.1 n >0 表示还有线程未到
12
        if (n > 0) {
13
            // 2.2 线程计数-1
14
            n--;
15
            
16
            // 2.3 n==0 表示当前线程为最后一个到达线程，此时唤醒其它线程
17
            if (n == 0) {
18
                notifyAll();
19
            } else {
20
                // 2.3 n>0 表示还有线程未到，进行等待
21
                while (n != 0) {
22
                    wait();
23
                }
24
            }
25
            
26
        }
27
    }
28
}

多个游客线程，各自先独立运行，然后使用该协作对象到达集合点进行同步的示例代码如下：

xxxxxxxxxx
37
1
// 需集合的线程
2
public class AssemblePointDemo {
3
    static class Tourist extends Thread {
4
        AssemblePoint ap; // 1. 共享变量
5

6
        public Tourist(AssemblePoint ap) {
7
            this.ap = ap;
8
        }
9

10
        @Override
11
        public void run() {
12
            try {
13
                // 2. 模拟先各自独立运行
14
                Thread.sleep((int) (Math.random() * 1000));
15

16
                // 3. 集合
17
                ap.await();
18
                System.out.println("arrived");
19
                
20
                // 4. 集合后执行其他操作
21
            } catch (InterruptedException e) {
22
            }
23
        }
24
    }
25

26
    // 主线程
27
    public static void main(String[] args) {
28
        // 1. 启动多个需集合的线程
29
        int num = 10;
30
        Tourist[] threads = new Tourist[num];
31
        AssemblePoint ap = new AssemblePoint(num);
32
        for (int i = 0; i < num; i++) {
33
            threads[i] = new Tourist(ap);
34
            threads[i].start();
35
        }
36
    }
37
}

5) 非阻塞调用模型

在并发编程中，一种常见的模式是将子线程的管理封装为非阻塞调用，非阻塞调用马上返回，但返回的不是最终的结果，而是一个一般称为Promise或Future的对象，通过它可以在随后获得最终的结果。

异步结果模式依赖异步调用框架，主要由调用者、执行器、异步任务、异步结果四个部分组成。

其中异步任务和异步结果代码表示如下：

xxxxxxxxxx
9
1
// 异步任务
2
public interface Callable<V> {
3
    V call() throws Exception;
4
}
5

6
// 异步结果
7
public interface MyFuture <V> {
8
    V get() throws Exception ; // 返回真正的结果。如果尚未计算完成，则等待。如果计算过程发生了异常，则抛出保存的异常。
9
}

执行器用于执行子任务并返回异步结果，使用执行器后调用者就无需创建并管理子线程了，其代码如下：

xxxxxxxxxx
78
1
// 执行器
2
public <V> MyFuture<V> execute(final Callable<V> task) {
3
    // 1. 创建锁对象
4
    final Object lock = new Object(); 
5
    
6
    // 2. 创建和启动执行线程
7
    final ExecuteThread<V> thread = new ExecuteThread<>(task, lock);
8
    thread.start();
9

10
    // 3. 创建异步结果对象，用于获取异步结果
11
    MyFuture<V> future = new MyFuture<V>() {
12
        @Override
13
        public V get() throws Exception {
14
            synchronized (lock) {
15
                
16
                // 3.1 执行线程未结束，则等待
17
                while (!thread.isDone()) {
18
                    try {
19
                        lock.wait();
20
                    } catch (InterruptedException e) {
21
                    }
22
                }
23
                
24
                // 3.2 执行过程中出现异常，在调用get时直接抛出异常
25
                if (thread.getException() != null) {
26
                    throw thread.getException(); 
27
                }
28
                
29
                // 3.3 执行线程完结束后，直接返回保存的真实结果
30
                return thread.getResult(); 
31
            }
32
        }
33
    };
34
    
35
    // 4. 返回一个异步结果对象
36
    return future;
37
}
38

39
// 执行器委托给执行线程去执行
40
static class ExecuteThread<V> extends Thread {
41
    private V result = null; // 结果
42
    private Exception exception = null; // 异常
43
    private boolean done = false; // 是否完成
44
    private Callable<V> task; // 任务
45
    private Object lock; // 锁对象
46
    
47
    public ExecuteThread(Callable<V> task, Object lock) {
48
        this.task = task;
49
        this.lock = lock;
50
    }
51

52
    @Override
53
    public void run() {
54
        // 1. 执行任务，捕获异常，修改完成标记，通知其它线程
55
        try {
56
            result = task.call();
57
        } catch (Exception e) {
58
            exception = e;
59
        } finally {
60
            synchronized (lock) {
61
                done = true;
62
                lock.notifyAll();
63
            }
64
        }
65
    }
66

67
    public V getResult() {
68
        return result;
69
    }
70

71
    public boolean isDone() {
72
        return done;
73
    }
74

75
    public Exception getException() {
76
        return exception;
77
    }
78
}

调用者只需创建执行器，然后执行异步任务，即可得到异步结果对象。

xxxxxxxxxx
28
1
public static void main(String[] args) {
2
    // 1. 创建执行器
3
    MyExecutor executor = new MyExecutor();
4
    
5
    // 2. 创建异步任务
6
    Callable<Integer> subTask = new Callable<Integer>() {
7
        @Override
8
        public Integer call() throws Exception {
9
            // 执行异步任务
10
            int millis = (int) (Math.random() * 1000);
11
            Thread.sleep(millis);
12
            return millis;
13
        }
14
    };
15
    
16
    // 3. 执行异步任务，返回异步结果
17
    MyFuture<Integer> future = executor.execute(subTask); // MyFuture执行的匿名内部类中对象中封装了执行线程对象
18
    
19
    // 4. 执行其他操作
20
    
21
    try {
22
        // 5. 获取异步调用的真实结果
23
        Integer result = future.get(); // 等待执行线程的finally中调用 lock.notifyAll() 
24
        System.out.println(result); // 6.1 处理真实结果
25
    } catch (Exception e) {
26
        e.printStackTrace(); // 6.2 处理异步任务异常
27
    }
28
}

4. 面试扩展

1) JMM简介

JMM是一个语言层面的内存模型抽象，用于描述多线程访问共享变量时的一系列行为规范。主要由两部分组成：

• 主内存：线程共享的内存区域，存储了所有实例对象、类信息、常量、静态变量等。
• 本地内存：线程私有的内存区域，存储了该线程读/写共享变量的副本。

交互原则：变量都存储在主内存中，在操作时，需从主内存复制一份副本到本地内存，修改完毕后，再写回主内存。

交互指令：lock(锁定)、unlock(解锁)、read(读取)、load(载入)、use(使用)、assign(赋值)、store(存储)、write(写入)。

注意：

1. JMM是抽象的，定义了线程与主内存、本地内存之间的交互规范，Java运行时内存区域是具体的，定义了运行时内存的划分。

2) sleep/wait/join/park的区别

• Thread::sleep(long ms)：Thread类的静态方法，用于暂停当前线程，期间不释放锁资源。
• Object.wait()/wait(long ms)：Object类的实例方法，需在synchronized代码中调用， 释放锁并等待，主要用于线程间的协作。
• Thread.join()/join(long ms)：Thread类的实例方法，主要用于线程顺序控制(如让子线程执行完后，主线程再继续)，也会释放锁。
• LockSupport::park()：LockSupport类的静态方法，可无锁调用，阻塞当前线程，但不释放锁或抛中断异常，主要用于实现AQS等。

3) CAS/syncchronized/Lock的对比

4) 悲观锁 vs 乐观锁

• 悲观锁：假设数据冲突是大概率事件，每次操作前都会加锁，禁止其它线程访问，适用于写操作较多、数据竞争激烈的场景。
• 乐观锁：假设数据冲突是小概率事件，先操作后再检查是否有冲突，如果有再重试，适用于读操作多、写操作少的场景。

注意：

1. 乐观锁无需切换上下文及内核态，在并发量低时，性能表现更好，可通过 CAS 来实现。

5) 关于死锁

当以不同顺序对多个资源进行加锁时，就可能造成死锁，即持有锁A的同时去获取锁B，但锁B已被其它线程持有且恰好需要获取锁A。

死锁检测：可通过jstack -pid命令查看。

避免死锁：

• 应该尽量避免在持有一个锁的同时去申请另一个锁，如果确实需要多个锁，所有代码都应该按照相同的顺序去申请锁。
• 在Java中，也有一些显式锁支持tryLock以及加锁超时的设定，也可以一定程度解决死锁问题。

xxxxxxxxxx
50
1
public class DeadLockDemo {
2
    private static Object lockA = new Object(); // 全局锁A
3
    private static Object lockB = new Object(); // 全局锁B
4

5
    // A线程
6
    private static void startThreadA() {
7
        Thread aThread = new Thread() {
8

9
            @Override
10
            public void run() {
11
                // 1. 线程A：先持有锁A，等待会后去申请锁B
12
                synchronized (lockA) {
13
                    try {
14
                        Thread.sleep(1000);
15
                    } catch (InterruptedException e) {
16
                    }
17
                    synchronized (lockB) {
18
                    }
19
                }
20
            }
21
        };
22
        aThread.start();
23
    }
24

25
    // B线程
26
    private static void startThreadB() {
27
        Thread bThread = new Thread() {
28
            @Override
29
            public void run() {
30
                // 2. 线程B：先持有锁B，等待会后去申请锁A
31
                synchronized (lockB) {
32
                    try {
33
                        Thread.sleep(1000);
34
                    } catch (InterruptedException e) {
35
                    }
36
                    synchronized (lockA) {
37
                    }
38
                }
39
            }
40
        };
41
        bThread.start();
42
    }
43

44
    public static void main(String[] args) {
45
        // 3. 启动两个线程，可能造成死锁(线程A等线程B释放B锁，线程B等待线程A释放A锁)
46
        startThreadA();
47
        startThreadB();
48
    }
49
}
50

6) 线程安全问题有哪些解决措施

线程表示一条单独的执行流，有各自的计数器和栈等，但是内存是共享的，并发操作就会存在竞争和内存可见性问题，解决思路如下：

• volatile：可解决内存可见性和指令重排序问题，在无需保证原子性时可以单独使用。
• CAS：基于硬件指令进行原子更新，配合死循环可实现原子变量，配合 LockSupport 等可实现 AQS 等。
• synchronized：Java内置同步机制，但它只有一个条件队列，且不响应中断，不能尝试加锁或超时加锁等。
• ReentrantLock：更灵活的悲观锁，可以响应中断、可以限时、可以指定公平性、可以避免死锁问题等。
• CopyOnWrite：写时复制，在修改时拷贝一份副本，修改好后通过 CAS 修改对象地址，支持读写兼容。
• ThreadLocal：每个线程都持有变量的独立副本，不同线程之间相互隔离，互不影响。

7) 线程之间的协作机制有哪些？

线程之间需要相互协作，来解决业务问题：

• wait/notify：在 synchronized 代码块中调用，通过一个锁等待队列和一个条件等待队列进行协作。

• signal/signalAll：在获取锁后，通过条件对象进行调用，可明确等待的条件和通知的线程，更为灵活可靠。

• park/unpark：无锁获取锁即可调用，park方法可让当前线程释放CPU进入等待，unpark方法则可唤醒指定的线程。

• 线程中断：给线程传递一个取消信号，但是由线程来决定如何以及何时退出，线程在不同状态和IO操作时对中断有不同的反应。

  • 线程的提供者，应该提供相应的取消/关闭方式，而不是让调用者贸然的调用线程中断。

• 协作工具类：如信号量（Semaphore）用于限制对资源的并发访问数，倒计时门栓（CountDownLatch）用于不同角色线程间的同步，循环栅栏（CyclicBarrier）用于同一角色线程间的协调一致。

• 阻塞队列：如基于数组的 ArrayBlockingQueue 和基于链表的 LinkedBlockingQueue 等，可用于实现生产者/消费者协作模式等。

• Future/FutureTask：主线程让子线程异步执行一项任务，随后获取其结果，常用于主从协作模式中。

第三节 线程本地变量

1. 基本使用

1) ThreadLocal简介

线程本地变量(ThreadLocal)指与线程绑定的变量，即每个线程都有同一个变量的独有拷贝，在Java中，用ThreadLocal表示。

xxxxxxxxxx
15
1
// 1. 构造方法
2
public ThreadLocal() // 有一个泛型，表示变量的实际类型
3
public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) // 静态方法，指定初始值构造
4

5
// 2. 获取和设置当前线程变量
6
public T get()
7
public void set(T value)
8

9
// 3. 提供初始值
10
// 默认无参构造无法提供初始值，通过重写如下方法，可提供初始值
11
protected T initialValue() // 当调用get方法时，如果之前没有set过，会调用该方法获取初始值，默认实现是返回null
12

13
// 4. 删掉当前线程对应的值
14
public void remove() // 如果删掉后，再次调用get，会再调用initialValue获取初始值
15

注意：

1. Thread内部存在一个 inheritableThreadLocals 变量，可用于跨线程传递 ThreadLocal 的值，但不支持线程池场景。
2. 阿里开源工具类可以解决上述问题：TransmittableThreadLocal，它自定义了线程类并对线程池进行了装饰。

2) 应用示例

xxxxxxxxxx
44
1
// 示例1：主线程和子线程操作同一个变量互不干扰
2
public class ThreadLocalBasic {
3
    // 定义线程本地变量，存储一个Integer
4
    static ThreadLocal<Integer> local = new ThreadLocal<>();
5

6
    public static void main(String[] args) throws InterruptedException {
7
        // 子线程
8
        Thread child = new Thread() {
9
            @Override
10
            public void run() {
11
                System.out.println("child thread initial: " + local.get()); // null
12
                local.set(200);
13
                System.out.println("child thread final: " + local.get()); // 200
14
            }
15
        };
16
        
17
        // 主线程
18
        local.set(100);
19
        child.start();
20
        child.join();
21
        System.out.println("main thread final: " + local.get()); // 100
22
    }
23
}
24

25
// 示例2：封装线程安全的SimpleDateFormat
26
public class ThreadLocalDateFormat {
27
    // 线程本地的DateFormat
28
    static ThreadLocal<DateFormat> sdf = new ThreadLocal<DateFormat>() {
29

30
        // 初始值为SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
31
        @Override
32
        protected DateFormat initialValue() {
33
            return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
34
        }
35
    };
36

37
    public static String date2String(Date date) {
38
        return sdf.get().format(date);
39
    }
40

41
    public static Date string2Date(String str) throws ParseException {
42
        return sdf.get().parse(str);
43
    }
44
}

注意：

1. 一般来说，ThreadLocal对象都定义为static，以便于引用。

2. 源码分析

1) 实现思路

在 Thread 类内部，有一个名为 threadLocals 的 ThreadLocalMap 对象，其 Key 为 ThreadLocal 对象的弱引用，Value 为该变量在该线程的值，在调用 ThreadLocal 的 get/set 方法时，就是获取当前线程的该变量进行 get/set，而 ThreadLocal 的作用更像是一个工具类。

2) set方法实现

每个线程都有一个ThreadLocalMap，调用set实际上是在线程自己的Map里设置了一个条目，键为当前的ThreadLocal对象，值为value。

xxxxxxxxxx
23
1
// ThreadLocal.set
2
public void set(T value) {
3
    // 1. 获取当前线程的ThreadLocalMap
4
    Thread t = Thread.currentThread();
5
    ThreadLocalMap map = getMap(t); 
6

7
    // 2. 创建和存储value
8
    if (map != null)
9
        map.set(this, value);
10
    else
11
        createMap(t, value);
12
}
13

14
// ThreadLocal.set -> getMap
15
ThreadLocalMap getMap(Thread t) {
16
    return t.threadLocals; // 返回线程的实例变量threadLocals，初始值为null
17
}
18

19
// ThreadLocal.set -> createMap
20
void createMap(Thread t, T firstValue) {
21
    t.threadLocals = new ThreadLocalMap(this, firstValue); 
22
}
23