生产者消费者问题java实现

以下是Java实现生产者消费者问题的示例代码：

import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;
import java.util.concurrent.Semaphore;

public class ProducerConsumerExample {

    private static final int BUFFER_SIZE = 10;
    private static final Semaphore mutex = new Semaphore(1);
    private static final Semaphore empty = new Semaphore(BUFFER_SIZE);
    private static final Semaphore full = new Semaphore(0);
    private static final Queue<Integer> buffer = new LinkedList<>();

    public static void main(String[] args) {
        Thread producer = new Thread(new Producer());
        Thread consumer = new Thread(new Consumer());
        producer.start();
        consumer.start();
    }

    static class Producer implements Runnable {
        private final Random random = new Random();

        @Override
        public void run() {
            while (true) {
                try {
                    int item = random.nextInt();
                    empty.acquire();
                    mutex.acquire();
                    buffer.add(item);
                    System.out.println("Produced item: " + item);
                    mutex.release();
                    full.release();
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    static class Consumer implements Runnable {
        @Override
        public void run() {
            while (true) {
                try {
                    full.acquire();
                    mutex.acquire();
                    int item = buffer.remove();
                    System.out.println("Consumed item: " + item);
                    mutex.release();
                    empty.release();
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

上述代码中，我们使用了信号量来实现线程之间的同步和互斥。其中，`mutex`是一个二元信号量，用于实现互斥访问共享缓冲区；`empty`是一个计数信号量，表示缓冲区中空闲的位置数；`full`也是一个计数信号量，表示缓冲区中已经存储的数据项数。

在生产者线程中，我们首先使用`empty.acquire()`获取一个空闲位置，然后使用`mutex.acquire()`获取互斥锁，向缓冲区中添加一个数据项，最后使用`mutex.release()`释放互斥锁，使用`full.release()`增加已存储的数据项数。

在消费者线程中，我们首先使用`full.acquire()`获取一个已存储的数据项，然后使用`mutex.acquire()`获取互斥锁，从缓冲区中移除一个数据项，最后使用`mutex.release()`释放互斥锁，使用`empty.release()`增加空闲位置数。