java里的生产者消费者模型

生产者消费者模型

TIP

这里的生产者消费者模型是最简单的模型：一个生产者、一个消费者、仓库容量 1 。

#monitor 对象版

在 Java 的世界中，所有的对象都可以做 “锁对象” 。注意，这里的 “锁对象” 是广义上的锁对象，并非单指 Lock 对象。用到的单词是 Monitor ，也叫检测对象。

但是对锁（Monitor）对象的使用，有一个特殊要求（其实也是有原因的）：在调用 Monitor 对象的 wait、signal 方法的调用必须在同步代码块（ synchronized ）中。

// 定义两个字符串常量充当锁（monitor）对象
private static final String canRead = "can read";
private static final String canWrite = "can write";

public static void main(String[] args) {

    // 消费者线程，执行读操作。从 “仓库” 中取走数据。
    Thread reader = new Thread(() -> {
        try {
            for (int i = 0; i < 26; i++) {

                synchronized (canRead) {
                    if (box == null)
                        canRead.wait(); // 当前线程阻塞在 canRead monitor 对象上 。
                }

                System.out.printf("%c ", box);
                box = null;

                synchronized (canWrite) {
                    canWrite.notify();  // 唤醒阻塞在 canWrite monitor 对象上的任一线程 。
                }
            }
            System.out.println();

        } catch (Exception e) {
            e.printStackTrace();
        }
    });

    // 生产者线程，执行写操作。向 “仓库” 中存放数据。
    Thread write = new Thread(() -> {
        for (char c = 'a'; c <= 'z'; c++) {
            try {
                synchronized (canWrite) {
                    if (box != null)
                        canWrite.wait();  // 当前线程阻塞在 canWrite monitor 对象上
                }

                box = c;
                synchronized (canRead) {
                    canRead.notify(); // 唤醒阻塞在 canRead monitor 对象上的任一线程
                }
                Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    });

    reader.start();
    write.start();
}

1

#条件变量版本

条件（Condition）变量是操作系统原理中的概念。各种操作系统都支持、实现了条件变量。作为虚拟机，JVM 也不例外。

条件变量和上面的锁（monitor）对象一样，都能造成当前线程的阻塞，造成 “当前线程阻塞在 xxx 条件变量上” 的情况，并且，同样也可以做到 “唤醒阻塞在 xxx 条件变量上的线程” 。

条件变量有一个特殊性：它来源于一个锁（Lock）对象。你要通过一个 Lock 对象来获得一个或多个条件变量，并且，你在操作条件变量之前，必须要先获得派生出它的那个 Lock 对象。

public static Lock synchronizedLock = new ReentrantLock();   // 用来“派生”条件变量的锁对象

// 条件（condition）变量来自于锁。
public static Condition canRead = synchronizedLock.newCondition();
public static Condition canWrite = synchronizedLock.newCondition();

public static void main(String[] args) {

    // 生产者线程。
    Thread writer = new Thread(() -> {
        for (char c = 'a'; c <= 'z'; c++) {
            try {
                synchronizedLock.lock();    // 获得派生出条件变量的那个锁对象。

                if (box != null)
                    canWrite.await();       // 当前线程阻塞在 canWrite 条件变量上

                box = c;
                canRead.signal();           // 唤醒阻塞在 canRead 条件变量上的线程
                synchronizedLock.unlock();  // 释放派生出条件变量的那个锁对象。
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });

    Thread reader = new Thread(() -> {
        try {
            for (int i = 0; i < 26; i++) {
                synchronizedLock.lock();    // 获得派生出条件变量的那个锁对象。
                if (box == null)
                    canRead.await();        // 当前线程阻塞在 canRead 条件变量上

                System.out.printf("%c ", box);
                box = null;
                canWrite.signal();          // 唤醒阻塞在 canWrite 条件变量上的任一线程
                synchronizedLock.unlock();  // 释放派生出条件变量的那个锁对象。
            }

            System.out.println();

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });

    writer.start();
    reader.start();

}

1

#信号量版本

信号量（Semaphore）也是操作系统原理中的概念。各种操作系统都支持、实现了条件变量。作为虚拟机，JVM 也不例外。

在使用经验上：信号量（背后的那个数字）代表的是资源数量。

• 生产者：需要的资源是 “坑位” 。 生产过程会导致 “坑位数 - 1” ，但是同时会导致 “商品数 + 1” ；
• 消费者：需要的资源是 “商品” 。 消费过程会导致 “商品数 - 1” ，但是同时会导致 “坑位数 + 1” 。

对信号量做减法，如果不够减（结果为负），会导致当前线程的阻塞；一直阻塞到够减，才会做这个减法，然后继续执行。

public static Semaphore productNum  = new Semaphore(0); // 初始状态，商品数为 0
public static Semaphore pitNum      = new Semaphore(1); // 初始状态，坑位数为 1

public static void main(String[] args) {

    Thread reader = new Thread(() -> {

        try {
            for (int i = 0; i < 26; i++) {
                    productNum.acquire();   // productNum - 1
                    System.out.printf("%c ", box);
                    pitNum.release(1);  // pitNum + 1
            }

            System.out.println();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });

    Thread write = new Thread(() -> {

        for (char c = 'a'; c <= 'z'; c++) {
            try {
                pitNum.acquire();   // pitNum - 1
                box = c;
                productNum.release(1);  // productNum + 1
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });

    reader.start();
    write.start();

}