使用java多线程，生成一个生产者线程，一个消费者线程，使两个线程完成同步进行生产和消费。

好的，我可以为你提供一个简单的示例代码：

import java.util.Queue;
import java.util.LinkedList;

public class ProducerConsumerExample {

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

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

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

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

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

    public void run() {
        for (int i = 0; i < 10; i++) {
            synchronized (buffer) {
                while (buffer.size() == maxSize) {
                    try {
                        System.out.println("Buffer is full, waiting for consumer to consume...");
                        buffer.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                buffer.add(i);
                System.out.println("Produced: " + i);
                buffer.notifyAll();
            }
        }
    }
}

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

    public Consumer(Queue<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 to produce...");
                        buffer.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                int num = buffer.poll();
                System.out.println("Consumed: " + num);
                buffer.notifyAll();
            }
        }
    }
}

在这个示例代码中，我们创建了一个名为 `ProducerConsumerExample` 的类作为程序入口，定义了一个队列 `buffer` 作为生产者和消费者共享的缓冲区，并且定义了一个缓冲区的最大大小 `maxSize`。

接着，我们创建了一个 `Producer` 类，实现了 `Runnable` 接口，用于定义生产者线程；同时，我们创建了一个 `Consumer` 类，也实现了 `Runnable` 接口，用于定义消费者线程。

在 `Producer` 类中，我们重复执行了十次生产操作，每次生产一个整数并将其添加到队列中。我们使用了 `synchronized` 关键字锁定了队列，以确保在生产者和消费者之间进行同步。

在 `Consumer` 类中，我们使用了一个无限循环来持续进行消费操作，从队列中取出一个整数并将其打印出来。同样地，我们使用了 `synchronized` 关键字锁定了队列，以确保在生产者和消费者之间进行同步。

最后，我们在 `main` 方法中创建了一个生产者线程和一个消费者线程，并启动了它们。这样，两个线程就可以同步进行生产和消费了。