多线程设计模式【多线程上下文设计模式、Guarded Suspension 设计模式、 Latch 设计模式】(二)-全面详解（学习总结---从入门到深化）

**多线程设计模式系列文章**

**第2 部分：多线程上下文设计模式、Guarded Suspension 设计模式、Latch 设计模式**

在前一篇文章中，我们讨论了生产者-消费者问题的解决方案。今天，我们将继续探索多线程设计模式，重点介绍三种重要的模式：多线程上下文设计模式、Guarded Suspension 设计模式和 Latch 设计模式。

### 多线程上下文设计模式多线程上下文设计模式是一种用于管理多线程执行的模式。它提供了一种机制来确保线程安全性，并且可以在多线程环境中使用。

**示例代码**

javapublic class ThreadContext {
 private final Object lock = new Object();

 public void execute(Runnable task) {
 synchronized (lock) {
 try {
 task.run();
 } finally {
 lock.notifyAll(); // 通知等待的线程 }
 }
 }

 public static void main(String[] args) throws InterruptedException {
 ThreadContext context = new ThreadContext();

 Runnable task = () -> System.out.println("Task executed");

 Thread thread = new Thread(() -> context.execute(task));
 thread.start();

 // 等待任务执行完成 thread.join();
 }
}

在这个示例中，我们定义了一个 `ThreadContext` 类，它提供了一个 `execute()` 方法来执行指定的任务。该方法使用同步块来确保线程安全性，并且在任务执行完成后通知等待的线程。

### Guarded Suspension 设计模式Guarded Suspension 设计模式是一种用于解决生产者-消费者问题的模式。它提供了一种机制来防止生产者和消费者之间的竞争。

**示例代码**

javapublic class GuardedSuspension {
 private final Object lock = new Object();
 private boolean canProduce;
 private boolean canConsume;

 public void produce() {
 synchronized (lock) {
 while (!canConsume) {
 try {
 lock.wait(); // 等待消费者准备好 } catch (InterruptedException e) {
 Thread.currentThread().interrupt();
 }
 }

 canProduce = false;
 System.out.println("Produced");
 canConsume = true;

 lock.notifyAll(); // 通知消费者 }
 }

 public void consume() {
 synchronized (lock) {
 while (!canProduce) {
 try {
 lock.wait(); // 等待生产者准备好 } catch (InterruptedException e) {
 Thread.currentThread().interrupt();
 }
 }

 canConsume = false;
 System.out.println("Consumed");
 canProduce = true;

 lock.notifyAll(); // 通知生产者 }
 }

 public static void main(String[] args) throws InterruptedException {
 GuardedSuspension suspension = new GuardedSuspension();

 Thread producerThread = new Thread(() -> {
 for (int i =0; i < 5; i++) {
 suspension.produce();
 }
 });
 producerThread.start();

 Thread consumerThread = new Thread(() -> {
 for (int i =0; i < 5; i++) {
 suspension.consume();
 }
 });
 consumerThread.start();

 // 等待任务执行完成 producerThread.join();
 consumerThread.join();
 }
}

在这个示例中，我们定义了一个 `GuardedSuspension` 类，它提供了两个方法： `produce()` 和 `consume()`。这两个方法使用同步块和等待机制来防止生产者和消费者之间的竞争。

### Latch 设计模式Latch 设计模式是一种用于解决生产者-消费者问题的模式。它提供了一种机制来确保生产者和消费者之间的线程安全性。

**示例代码**

javapublic class Latch {
 private final Object lock = new Object();
 private int count;

 public void await() {
 synchronized (lock) {
 while (count !=0) {
 try {
 lock.wait(); // 等待生产者准备好 } catch (InterruptedException e) {
 Thread.currentThread().interrupt();
 }
 }

 count =0;
 lock.notifyAll(); // 通知消费者 }
 }

 public void countDown() {
 synchronized (lock) {
 count++;
 System.out.println("Count: " + count);
 if (count ==5) {
 lock.notifyAll(); // 通知消费者 }
 }
 }

 public static void main(String[] args) throws InterruptedException {
 Latch latch = new Latch();

 Thread producerThread = new Thread(() -> {
 for (int i =0; i < 5; i++) {
 latch.countDown();
 }
 });
 producerThread.start();

 Thread consumerThread = new Thread(() -> {
 for (int i =0; i < 5; i++) {
 latch.await();
 }
 });
 consumerThread.start();

 // 等待任务执行完成 producerThread.join();
 consumerThread.join();
 }
}

在这个示例中，我们定义了一个 `Latch` 类，它提供了两个方法： `await()` 和 `countDown()`。这两个方法使用同步块和等待机制来确保生产者和消费者之间的线程安全性。

以上就是关于多线程设计模式的第二部分内容。在下一篇文章中，我们将继续探索其他重要的设计模式。