Java模拟生产者/消费者问题，验证线程通过同步等方法解决死锁问题代码

以下是一个使用Java多线程模拟生产者/消费者问题的示例代码，其中使用了同步方法来解决可能出现的死锁问题：

public class ProducerConsumerExample {
    private static Queue<Integer> buffer = new LinkedList<>();
    private static final int BUFFER_SIZE = 10;
    
    public static void main(String[] args) throws InterruptedException {
        Thread producerThread = new Thread(new Producer());
        Thread consumerThread = new Thread(new Consumer());
        
        producerThread.start();
        consumerThread.start();
        
        producerThread.join();
        consumerThread.join();
    }
    
    static class Producer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 50; i++) {
                try {
                    produce(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        
        private void produce(int i) throws InterruptedException {
            synchronized (buffer) {
                while (buffer.size() == BUFFER_SIZE) {
                    System.out.println("Buffer is full. Waiting for consumer to consume.");
                    buffer.wait();
                }
                
                buffer.add(i);
                System.out.println("Produced " + i);
                buffer.notifyAll();
            }
        }
    }
    
    static class Consumer implements Runnable {
        @Override
        public void run() {
            while (true) {
                try {
                    consume();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        
        private void consume() throws InterruptedException {
            synchronized (buffer) {
                while (buffer.isEmpty()) {
                    System.out.println("Buffer is empty. Waiting for producer to produce.");
                    buffer.wait();
                }
                
                int value = buffer.poll();
                System.out.println("Consumed " + value);
                buffer.notifyAll();
            }
        }
    }
}

在这个示例代码中，我们定义了一个缓冲区 `buffer`，使用 `LinkedList` 来实现队列的功能。我们通过两个内部类 `Producer` 和 `Consumer` 来分别模拟生产者和消费者线程。在 `Producer` 内部，我们使用 `synchronized` 关键字来保证在多线程环境下对 `buffer` 的访问是互斥的。当 `buffer` 已满时，生产者线程将等待消费者线程消费一部分数据之后再继续生产。在 `Consumer` 内部同样使用 `synchronized` 关键字来保证对 `buffer` 的访问是互斥的。当 `buffer` 为空时，消费者线程将等待生产者线程生成一些新的数据。

注意，在使用 `wait()` 和 `notifyAll()` 方法时，必须在同步块中调用，否则会抛出 `IllegalMonitorStateException` 异常。

通过这种方式，我们可以保证生产者和消费者线程之间的同步，避免了死锁问题的发生。