用java写一个生产者和消费者模式的缓存延迟双删例子

好的，以下是一个用 Java 实现的生产者和消费者模式的缓存延迟双删例子：

import java.util.LinkedList;

public class ProducerConsumerExample {
    public static void main(String[] args) {
        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();

        // 等待线程结束
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    // 生产者和消费者共享的缓存区
    public static class PC {
        LinkedList<Integer> list = new LinkedList<>();
        int capacity = 1;

        // 生产者方法
        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);

                    // 再次检查缓存区是否为空，如果为空则删除缓存区
                    if (list.size() == 0) {
                        list = null;
                        break;
                    }
                }
            }
        }
    }
}

这个例子中，我们使用了一个 LinkedList 作为生产者和消费者共享的缓存区，生产者线程不断向缓存区中添加值，消费者线程不断从缓存区中取出值。当缓存区已满时，生产者线程会等待，当缓存区为空时，消费者线程会等待。为了模拟生产和消费的延迟，我们在生产者和消费者方法中都加入了 Thread.sleep() 方法。此外，我们还加入了一个双删机制，当缓存区为空时，消费者线程会将缓存区删除。