并发设计模式

发表于 2025-11-27 更新于 2025-12-21 分类于 concurrent

快速学习并发编程的各种模式设计。

Thread

wait，当前线程释放实例对象的锁，状态变为等待并进入等待队列，其他线程获取锁然后执行相关操作。
sleep，当前线程不会释放实例对象的锁，其他想要获取锁的线程仍然被阻塞
notify/notifyAll/interrupt/超时，通知等待队列中的线程，重新尝试去获取实例对象的锁，如果没有获取到，则进入阻塞状态

中断线程

当执行 interrupt 时, 线程并不需要获取 Thread 实例的锁。无论何时,任何线程都可以调用其他线程的 interrupt 方法。

interrupt方法只是改变了线程的中断状态而已。所谓中断状态 (interrupted status),是一种用于表示线程是否被中断的状态。

正在 sleep/join 的线程被 interrupt 之后，因为本身就持有锁，所以会立即终止暂停状态, 抛出 InterruptedException 异常。

正在 wait 的线程被调用 interrupt 方法时, 该线程会在重新获取锁之后, 抛出 InterruptedException 异常。在获取锁之前, 线程不会抛出 InterruptedException 异常。

如果没有调用 sleep、wait、join 等方法, 或者没有编写检查线程的中断状态，并抛出 InterruptedException 异常的代码, 那么 InterruptedException 异常就不会被抛出。

Single Thread Execution Pattern

该模式通过对有状态并且状态会变化的共享资源设置临界区，来限制同一时间只能让一个线程执行处理。一般通过悲观锁对不安全的方法设置临界区，使其同一时间只能被一个线程访问。。

void unsafeMethod() {
    // 通过获取锁，进入临界区
    lock();
    try {
        ...
    } finally {
        // 无论何时，都要保证在最后的时候锁要被释放
        unlock();
    }
}

该模式会降低性能，抑制性能下降的方法：

尽量减少状态会变化的共享资源的数量，以减少需要获取的锁的数量
尽量缩小临界区的范围，以降低线程冲突的概率，就能抑制性能的下降。

计数信号量 Semaphore

Semaphore 可以用来控制线程的数量，来确保临界区最多只能由 N 个线程执行。

class SharedResource {
    private final Semaphore semaphore;

    public SharedResource(int permits) {
        semaphore = new Semaphore(permits);
    }

    void unsafeMethod() {
        semaphore.acquire();
        try {
            ...
        } finally {
            semaphore.release();
        }
    }
}

Immutable Pattern

该模式保证共享资源的状态不可变，所以也就不需要执行耗时的互斥处理，进而提高程序的性能。

Immutable 的实例被创建后，其状态就不再发生变化。

适用的场景：

实例创建后，其状态不再发生变化
共享并且频繁被访问

Mutable 和 Immutable 成对出现

Mutable 实例用于构建 Immutable 实例，可被修改； Immutable 实例则用于共享。两者可以根据需求，互相转换。

Guarded Suspension Pattern

该模式通过让线程等待来保证共享资源的安全性，当守护条件(guard condition)不成立时，让线程等待，直到守护条件满足才能执行操作。

synchronized void guardedMethod（） {
    ...
    while (isGuradConditionFalse()) {
        try {
            // 守护条件不满足，则等待
            wait();
        } catch (InterruptedException e) {
        }
    }
    // 守护条件满足，则执行目标操作
    ...
}

synchronized void stateChangingMethod() {
    ...
    // 更新状态后，通知等待队列中的线程重新检查守护条件
    notiyAll();
    ...
}

Balking Pattern

该模式用于当守护条件不满足时，就停止处理，直接返回，而 Guarded Suspension Pattern 则是一直等待。

synchronized void guardedMethod() {
    ...
    while (isGuradConditionFalse()) {
        try {
            // 守护条件不满足，则停止处理，直接返回
            return;
        } catch (InterruptedException e) {
        }
    }
    // 守护条件满足，则执行目标操作
    ...
}

针对守护条件不满足时，停止处理的方式:

直接 return, 没有返回值
return 有返回值
抛出异常

通过 Balking Pattern 和 Guarded Suspension Pattern 实现超时等待

synchronized void guardedMethod() throws InterruptedException, TimeoutException {
    ...
    long start = System.currentTimeMillis();
    while (isGuradConditionFalse()) {
        long now = System.currentTimeMillis();
        long rest = now - start;
        if (rest <= 0) {
            // 守护条件不满足并且超时，则停止处理
            throw new TimeoutException();
        }
        // 守护条件不满足，但未超时，则等待
        wait(rest);
    }
    // 守护条件满足，则执行目标操作
    ...
}