生产者消费者问题代码实现

生产者消费者问题是一个经典的多线程同步问题，下面是一个简单的Java代码实现：

import java.util.LinkedList;

public class ProducerConsumerProblem {
    public static void main(String[] args) throws InterruptedException {
        final PC pc = new PC();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    pc.produce();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    pc.consume();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();
    }

    public static class PC {
        LinkedList<Integer> list = new LinkedList<>();
        int capacity = 2;

        public void produce() throws InterruptedException {
            int value = 0;
            while (true) {
                synchronized (this) {
                    while (list.size() == capacity) {
                        wait();
                    }

                    System.out.println("Producer produced-" + value);

                    list.add(value++);

                    notify();

                    Thread.sleep(1000);
                }
            }
        }

        public void consume() throws InterruptedException {
            while (true) {
                synchronized (this) {
                    while (list.size() == 0) {
                        wait();
                    }

                    int val = list.removeFirst();

                    System.out.println("Consumer consumed-" + val);

                    notify();

                    Thread.sleep(1000);
                }
            }
        }
    }
}

在这个例子中，我们定义了一个类`PC`，里面包含了一个容量为2的链表`list`。`produce()`方法向链表中添加元素，`consume()`方法从链表中删除元素。在`produce()`和`consume()`方法中，我们使用`synchronized`关键字确保线程安全，使用`wait()`和`notify()`方法实现线程间的协作。

当链表已满时，`produce()`方法调用`wait()`方法，线程进入等待状态；当链表为空时，`consume()`方法调用`wait()`方法，线程进入等待状态。当新元素被添加到链表中时，`notify()`方法被调用，唤醒一个等待的线程。当元素被消费时，`notify()`方法被调用，唤醒一个等待的线程。

运行这个程序，你会看到生产者和消费者交替执行的结果。