Java生產者消費者模型

在多線程編程中，生產者消費者模型是一個經典的問題。它是指有兩個線程，一個是生產者，一個是消費者，它們共享同一個數據緩衝區。生產者線程向數據緩衝區中添加數據，而消費者線程從緩衝區中取出數據。

Java提供了多種機制來實現生產者消費者模型，本文將介紹其中兩種：使用wait()和notifyAll()方法以及使用BlockingQueue。

一、使用wait()和notifyAll()方法

這種方法需要自己實現緩衝區，並調用Object類的wait()和notifyAll()方法來實現線程之間的同步。具體實現如下：

class Buffer {
    private Queue<Integer> queue = new LinkedList<>();
    private int maxSize;

    public Buffer(int size) {
        this.maxSize = size;
    }

    public synchronized void addToBuffer(int number) {
        while (queue.size() == maxSize) {
            try {
                wait(); 
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); 
                return;
            }
        }
        queue.add(number);
        notifyAll(); 
    }

    public synchronized int getFromBuffer() {
        while (queue.isEmpty()) {
            try {
                wait(); 
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); 
                return -1;
            }
        }
        int number = queue.remove();
        notifyAll(); 
        return number;
    }
}

在這個例子中，Buffer類表示緩衝區，addToBuffer方法往緩衝區中添加數據，getFromBuffer方法從緩衝區中取出數據。如果緩衝區已滿，線程會阻塞等待緩衝區被取走一部分；如果緩衝區為空，線程會阻塞等待緩衝區被填充。

使用wait()和notifyAll()方法可以實現生產者消費者模型，但是需要手動同步和管理線程的狀態，容易出現錯誤。如果有更好的方法，還是應該優先考慮其他的方式。

二、使用BlockingQueue

Java的java.util.concurrent包提供了一個BlockingQueue接口，實現了線程安全的隊列操作。由於BlockingQueue是線程安全的，所以可以很方便地實現生產者消費者模型。

示例代碼如下：

class Producer implements Runnable {
    private BlockingQueue<Integer> queue;
    private int maxSize;

    public Producer(BlockingQueue<Integer> queue, int size) {
        this.queue = queue;
        this.maxSize = size;
    }

    @Override
    public void run() {
        for (int i = 0; i < maxSize; i++) {
            try {
                queue.put(i);
                System.out.println("Producing: " + i);
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Consumer implements Runnable {
    private BlockingQueue<Integer> queue;

    public Consumer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Integer number = queue.take();
                System.out.println("Consuming: " + number);
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);
        Producer producer = new Producer(queue, 10);
        Consumer consumer = new Consumer(queue);
        new Thread(producer).start();
        new Thread(consumer).start();
    }
}

這段代碼中使用了ArrayBlockingQueue來實現，ArrayBlockingQueue的大小為10。Producer類是生產者線程，不停地往隊列中添加數據；Consumer類是消費者線程，不停地從隊列中取出數據。在Main類中創建生產者和消費者線程，並啟動它們。

三、總結

生產者消費者模型是一個經典的多線程問題，它可以應用於很多實際應用場景中。Java提供了多種方式來實現這個模型，其中比較常用的有使用wait()和notifyAll()方法和使用BlockingQueue。使用BlockingQueue可以簡化代碼，避免手動同步和管理線程狀態的問題，更適合實際應用。