Java多线程同步问题：生产者-消费者模型实例

原创我就是我 2024-09-10 22:03 101阅读 0赞

在Java中实现生产者-消费者模型，通常我们会使用`synchronized`关键字、`Lock`接口或者`ReentrantLock`类来实现线程同步。

以下是一个简单的例子：

1. 创建一个商品类（Product）和两个队列（Queue）：
```java
import java.util.LinkedList;
import java.util.Queue;

public class Product {
    private String name;
    private int quantity;

// getters and setters
}
```
```java
class QueueImpl<T> implements Queue<T> {
    private LinkedList<T> list = new LinkedList<>();

@Override
    public synchronized boolean isEmpty() {
        return list.isEmpty();
    }

@Override
    public synchronized int size() {
        return list.size();
    }

@Override
    public synchronized T remove() {
        return list.removeFirst();
    }

// add methods
}
```
2. 创建生产者（Producer）和消费者（Consumer）类：
```java
class Producer implements Runnable {
    private QueueImpl<Product> queue;

public Producer(QueueImpl<Product> queue) {
        this.queue = queue;
    }

@Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            Product product = new Product("Product " + i, i * 2));
            queue.add(product);
            System.out.println("Producer added product: " + product.getName());
            try {
                Thread.sleep(500); // sleep for a moment
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Consumer implements Runnable {
    private QueueImpl<Product> queue;

public Consumer(QueueImpl<Product> queue) {
        this.queue = queue;
    }

@Override
    public void run() {
        while (!queue.isEmpty()) {
            Product product = queue.removeFirst();
            System.out.println("Consumer removed product: " + product.getName());
            try {
                Thread.sleep(1000); // sleep for a moment
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
```
3. 运行生产者和消费者线程：
```java
public class Main {
    public static void main(String[] args) {
        QueueImpl<Product> queue = new QueueImpl<>();
        Producer producer = new Producer(queue);
        Consumer consumer = new Consumer(queue);

// 创建并启动线程
        Thread producerThread = new Thread(producer);
        producerThread.start();

Thread consumerThread = new Thread(consumer);
        consumerThread.start();

try {
            // 等待所有线程执行完毕
            producerThread.join();
            consumerThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```
这样，生产者和消费者就可以通过队列进行同步通信了。