应用多线程同步机制，模拟生产者消费者问题。

以下是一个简单的生产者消费者问题的实现，使用Java的多线程同步机制：

import java.util.LinkedList;

public class ProducerConsumer {

    public static void main(String[] args) {
        LinkedList<Integer> buffer = new LinkedList<>();
        int maxSize = 10;

        Thread producer = new Thread(new Producer(buffer, maxSize));
        Thread consumer = new Thread(new Consumer(buffer));

        producer.start();
        consumer.start();
    }
}

class Producer implements Runnable {
    private LinkedList<Integer> buffer;
    private int maxSize;

    public Producer(LinkedList<Integer> buffer, int maxSize) {
        this.buffer = buffer;
        this.maxSize = maxSize;
    }

    public void run() {
        while (true) {
            synchronized (buffer) {
                while (buffer.size() == maxSize) {
                    try {
                        System.out.println("Buffer is full, waiting for consumer...");
                        buffer.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                int num = (int) (Math.random() * 100);
                buffer.add(num);
                System.out.println("Produced: " + num);
                buffer.notifyAll();
            }
        }
    }
}

class Consumer implements Runnable {
    private LinkedList<Integer> buffer;

    public Consumer(LinkedList<Integer> buffer) {
        this.buffer = buffer;
    }

    public void run() {
        while (true) {
            synchronized (buffer) {
                while (buffer.isEmpty()) {
                    try {
                        System.out.println("Buffer is empty, waiting for producer...");
                        buffer.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                int num = buffer.removeFirst();
                System.out.println("Consumed: " + num);
                buffer.notifyAll();
            }
        }
    }
}

上述代码中，我们创建了一个 `Producer` 类和一个 `Consumer` 类，分别代表生产者和消费者。它们都实现了 `Runnable` 接口，可以在新的线程中运行。

在 `Producer` 类中，我们使用 `while` 循环来不断地生产数据。在每次循环中，首先获取 `buffer` 对象的锁，然后检查缓冲区是否已满。如果是，就调用 `wait()` 方法等待消费者消费。否则，生成一个随机数并添加到缓冲区中，打印出生产的数字，然后调用 `notifyAll()` 方法唤醒所有等待中的线程。

在 `Consumer` 类中，我们使用 `while` 循环来不断地消费数据。在每次循环中，首先获取 `buffer` 对象的锁，然后检查缓冲区是否为空。如果是，就调用 `wait()` 方法等待生产者生产。否则，从缓冲区中取出第一个数字，打印出消费的数字，然后调用 `notifyAll()` 方法唤醒所有等待中的线程。

在 `main` 方法中，我们创建了一个 `LinkedList` 对象作为缓冲区，设置了缓冲区的最大大小为 10。然后创建了一个 `Producer` 对象和一个 `Consumer` 对象，并将它们分别放入新的线程中运行。

注意，在任何时候只能有一个线程访问共享资源（即缓冲区），因此我们必须使用 `synchronized` 来保证线程同步。在 `Producer` 和 `Consumer` 类中，我们都使用了 `synchronized (buffer)` 来获取缓冲区的锁。这样，当一个线程正在使用缓冲区时，其他线程必须等待它释放锁之后才能访问缓冲区。