多线程通信与设计模式

线程通信概述

多线程程序的成功运行离不开良好的通信机制。典型的生产者-消费者模式展示了线程间如何通过共享资源进行数据交换。生产者生成数据，消费者消耗数据，整个系统需确保数据的生产和消费同步进行。

消息队列模式

在实际应用中，生产者和消费者的数据交换可以通过消息队列来实现：

生产者：检查消息队列是否有数据（isEmpty()）？如果无数据，生成新数据并将其放入队列。

消费者：从队列中取出数据（take()）？处理后，通知生产者继续产生新的数据。

Java多线程模板一

基于生产者-消费者的逻辑，可以得到线程模板：

判断：检查是否有产品可用。

操作：如果无产品，生产（制造新产品）；如果有产品，消费（处理当前产品）。

通知：完成操作后，通知对方系统当前操作已完成。

此模式的实现需注意：

Java 线程 awaits 判断条件，直接用 if 可能引发虚假唤醒。

Java多线程模板二

改进代码后，我们回顾线程条件判断的最优做法：

虚假唤醒（spurious wake-up）可能发生，必须使用 while 循环而非 if。

处理多个线程之前，确保共享资源的完整性。即使初始增加线程数，需通过具体逻辑控制其操作。

Java多线程模板三

代码示例对比：不正确版本：

class NUM {    private int number = 0;    public synchronized void increment() {        if (number != 0) {            wait();        }        number++;        ...    }    // 其他方法类似}

改进版本：

class NUM {    private int number = 0;    public synchronized void increment() {        while (number != 0) {            wait();        }        number++;        ...    }    // 其他方法类似}

此处的关键点是将 if 判断改为 while 循环，避免物理条件判断时的错误操作。

Java多线程模板四

使用 Lock 和 Condition 对象：

class NUM {    private int number = 0;    private Lock lock = new ReentrantLock();    private Condition condition = lock.newCondition();    public void increment() {        lock.lock();        try {            while (number != 0) {                condition.await();            }            number++;            System.out.println(...);            condition.signalAll();        } catch (Exception e) { ... } finally { lock.unlock(); }    }}

此模式的优点：

提供更高的控制力和更精准的唤醒机制，避免其他线程强行中断等情况的干扰。

线程间定制化通信

题目要求：

允许四个线程按顺序执行：A print 1，B print 2，C print 3，D print 4，共10轮。

严格按照 A→B→C→D 的顺序执行。

实现方法：

使用 Lock 与 Condition 对象。

每个 thread 有自己的 condition 对象。

state 表示当前的打印顺序：

A: 0

B: 1

C: 2

D: 3

示例代码：

class ShareResource {    private int state = 0;    private Lock lock = new ReentrantLock();    private Condition conditionA = lock.newCondition();    private Condition conditionB = lock.newCondition();    private Condition conditionC = lock.newCondition();    private Condition conditionD = lock.newCondition();    public void printA() {        print(0, conditionA, conditionB);    }    public void printB() {        print(1, conditionB, conditionC);    }    public void printC() {        print(2, conditionC, conditionD);    }    public void printD() {        print(3, conditionD, conditionA);    }    private void print(int currentState, Condition currentCondition, Condition nextCondition) {        for (int i = 0; i < 10; ) {            lock.lock();            try {                while (state % 4 != currentState) {                    currentCondition.await();                }                for (int j = 0; j < (state % 4 + 1); j++) {                    System.out.println(Thread.currentThread().getName() + " print " + (j + 1));                }                state++;                i++;                nextCondition.signal();            } catch (InterruptedException e) { ... } finally { lock.unlock(); }        }    }}

上述实现：

适合多线程按顺序执行，确保每个 thread 的操作严格遵循指定顺序。

使用 Lock 提供更高级别的线程安全控制。

转载地址：http://yklez.baihongyu.com/

你可能感兴趣的文章