Java并发编程：生产者消费者模型实例

原创爱被打了一巴掌 2024-10-06 19:39 74阅读 0赞

在Java并发编程中，"生产者消费者模型"是一个常见的并发实践案例，它通过两个角色：生产者和消费者，来模拟资源的供需过程。

以下是一个简单的实例：

```java
import java.util.concurrent.*;

class Product {
    private int id;
    private String name;

public Product(int id, String name) {
        this.id = id;
        this.name = name;
    }

// getters and setters
}

// 生产者类
class Producer extends Thread {
    private Queue<Product> productsQueue;
    private int productCount;

public Producer(Queue<Product> productsQueue) {
        this.productsQueue = productsQueue;
        this.productCount = 0; // 初始化产品数量为0
    }

@Override
    public void run() {
        while (true) {
            try {
                // 生产1个新产品
                Product product = new Product(productCount++, "Product " + productCount));

// 将新产品加入队列
                productsQueue.put(product);

Thread.sleep(100); // 模拟生产过程，每隔100毫秒生产一个新产品
            } catch (InterruptedException e) {
                e.printStackTrace();
                break;
            }
        }
    }
}

// 消费者类
class Consumer extends Thread {
    private Queue<Product> productsQueue;

public Consumer(Queue<Product> productsQueue) {
        this.productsQueue = productsQueue;
    }

@Override
    public void run() {
        while (true) {
            try {
                // 从队列中获取产品（如果有的话）
                Product product = productsQueue.poll();

// 模拟消费者消费产品
                if (product != null) {
                    System.out.println("Consumer consumed: " + product.getName());
                } else {
                    System.out.println("No product available in queue.");
                }

Thread.sleep(500); // 模拟消费过程，每隔500毫秒消费一个产品
            } catch (InterruptedException e) {
                e.printStackTrace();
                break;
            }
        }
    }
}

// 主程序
public class Main {
    public static void main(String[] args) {
        // 创建生产者和消费者队列
        Queue<Product> productsQueue = new LinkedBlockingQueue<>(10); // 队列容量为10，当队列满时会阻塞

// 创建生产者和消费者线程
        Producer producer = new Producer(productsQueue);
        Consumer consumer = new Consumer(productsQueue);

// 启动生产者和消费者线程
        producer.start();
        consumer.start();

// 等待生产者和消费者线程执行完毕
        try {
            producer.join(); // 与生产者线程一起等待
            consumer.join(); // 与消费者线程一起等待
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

这个例子中，`Product`类代表产品，`Producer`和`Consumer`类分别模拟生产者和消费者。通过主线程启动生产者和消费者线程，并在他们执行完毕后结束程序。