Java线程同步问题：一个生产者消费者案例

原创柔情只为你懂 2024-09-12 21:27 48阅读 0赞

在Java中，线程同步是通过各种锁（如synchronized关键字）实现的，以确保同一时间只有一个线程可以执行特定代码块。

下面是一个简单的生产者消费者案例，用到了synchronized关键字：

```java
// 假设我们有一个固定大小的缓冲队列
class Buffer {
    private int capacity = 10;
    private int[] items = new int[capacity];

// 添加元素到缓冲队列尾部
    synchronized void add(int item) {
        if (items.length == capacity) {
            // 队列已满，无法添加
            System.out.println("Buffer is full, can't add " + item);
            return;
        }
        items[items.length - 1] = item;
    }

// 从缓冲队列头部移除元素
    synchronized int remove() {
        if (items.length == 0) {
            // 队列为空，无法移除
            System.out.println("Buffer is empty, can't remove");
            return -1; // 返回一个表示失败的值
        }
        int removedItem = items[0];
        items[0] = 0; // 假设索引为0

// 移除后，可能需要更新队列的容量
        if (items.length == 1) {
            capacity--;
        }

return removedItem;
    }
}

// 生产者类
class Producer extends Thread {
    private Buffer buffer;

public Producer(Buffer buffer) {
        this.buffer = buffer;
    }

@Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) { // 创建并生产10个元素
                buffer.add(i); // 将元素添加到缓冲队列尾部
            }
            System.out.println("Producer done, waiting..."); // 生产者完成任务后等待消费者开始工作
        } catch (Exception e) {
            System.out.println("Error in producer thread: " + e.getMessage());
        }
    }
}

// 消费者类
class Consumer extends Thread {
    private Buffer buffer;

public Consumer(Buffer buffer) {
        this.buffer = buffer;
    }

@Override
    public void run() {
        try {
            System.out.println("Consumer starting..."); // 消费者开始工作

while (true) { // 无限循环，直到生产者停止
                int removedItem = buffer.remove(); // 从缓冲队列头部移除元素
                if (removedItem == -1) { // 如果移除失败（缓冲队列为空）
                    System.out.println("Error in consumer thread: Buffer is empty, can't remove item"); 
                    break; // 结束循环
                }
                System.out.println("Removed item from buffer: " + removedItem); // 打印移除元素的值
            }
        } catch (Exception e) {
            System.out.println("Error in consumer thread: " + e.getMessage());
        }
    }
}

// 主程序，创建并启动生产者和消费者线程
public class Main {
    public static void main(String[] args) {
        Buffer buffer = new Buffer(); // 创建缓冲队列

Producer producer = new Producer(buffer); // 创建生产者线程
        producer.start(); // 启动生产者线程

Consumer consumer = new Consumer(buffer); // 创建消费者线程
        consumer.start(); // 启动消费者线程

System.out.println("Main thread done, waiting..."); // 主程序完成任务后等待其他线程结束工作
    }
}
```

这段代码中，生产者负责创建元素并将其添加到缓冲队列尾部。消费者则从缓冲队列头部移除元素，并进行处理。

这样的设计可以确保在不产生新的元素时，消费者不会一直等待，从而提高了系统的效率。