Java多线程同步问题：生产者与消费者的实战案例

原创小咪咪 2024-10-15 01:06 33阅读 0赞

在Java中，我们可以使用synchronized关键字和线程池来实现生产者与消费者之间的实战案例。以下是一个基础的例子：

1. 生产者类（Producer）：
```java
import java.util.concurrent.*;

public class Producer {
    private int count;
    private BlockingQueue<Integer> queue;

public Producer(BlockingQueue<Integer> queue) {
        this.queue = queue;
        count = 0;
    }

public synchronized void produce() {
        count++;
        System.out.println("Producer produced: " + count);

if (count == 10) { // 假设生产了10个产品
            System.out.println("Producer finished producing.");
            count = 0; // 清空计数器
        }

try {
            queue.put(count); // 将生产的产品放入队列
            System.out.println("Product put into queue: " + count);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

2. 消费者类（Consumer）：
```java
import java.util.concurrent.*;

public class Consumer {
    private int count;
    private BlockingQueue<Integer> queue;

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

public synchronized void consume() {
        System.out.println("Consumer started consuming.");

try {
            count = queue.take(); // 从队列中取出一个产品
            System.out.println("Product consumed: " + count);

if (count % 5 == 0) { // 假设消费者每消费5个产品会休息一下
                System.out.println("Consumer resting after consuming.");
                Thread.sleep(1000); // 线程休眠，模拟休息
            }

System.out.println("Product consumed and put back into queue: " + count);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

3. 主程序：
```java
import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10); // 初始化队列大小

Producer producer = new Producer(queue);
        Consumer consumer = new Consumer(queue);

Thread producerThread = new Thread(producer, "Producer"));
        Thread consumerThread = new Thread(consumer, "Consumer"));

producerThread.start(); // 开始生产者线程
        consumerThread.start(); // 开始消费者线程

// 等待所有线程结束
        producerThread.join();
        consumerThread.join();
    }
}
```

这个例子中，生产者不断地向队列（消费者可以访问的共享资源）添加产品，而消费者则从队列中取出产品并消费。当产品达到10个时，生产者会暂停，让消费者完成消费。