请编写一个生产者与消费者的程序，生产者不断地生产产品，即令产品数量增加，消费者不断的消费产品，即令产品数量减少。 主线程中分别定义2个生产者线程对象及2个消费者线程对象，模拟生产与消费过程（例如：生产者每次生产5个产品后休眠50ms，消费者每次消费6个产品后休眠60ms）。 请恰当使用同步机制及wait等方法

以下是一个使用同步机制及wait等方法的生产者与消费者模拟程序的示例：

public class ProducerConsumerExample {
    private static final int MAX_CAPACITY = 10;
    private static List<Integer> sharedQueue = new LinkedList<Integer>();
    
    public static void main(String[] args) {
        Thread t1 = new Thread(new Producer(), "Producer1");
        Thread t2 = new Thread(new Producer(), "Producer2");
        Thread t3 = new Thread(new Consumer(), "Consumer1");
        Thread t4 = new Thread(new Consumer(), "Consumer2");
        
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
    
    static class Producer implements Runnable {
        @Override
        public void run() {
            while (true) {
                synchronized (sharedQueue) {
                    while (sharedQueue.size() == MAX_CAPACITY) {
                        try {
                            System.out.println(Thread.currentThread().getName() + " is waiting, size: " + sharedQueue.size());
                            sharedQueue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    int value = produce();
                    sharedQueue.add(value);
                    System.out.println(Thread.currentThread().getName() + " produced " + value + ", size: " + sharedQueue.size());
                    sharedQueue.notifyAll();
                }
                sleep(50);
            }
        }
        
        private int produce() {
            return (int) (Math.random() * 100);
        }
    }
    
    static class Consumer implements Runnable {
        @Override
        public void run() {
            while (true) {
                synchronized (sharedQueue) {
                    while (sharedQueue.isEmpty()) {
                        try {
                            System.out.println(Thread.currentThread().getName() + " is waiting, size: " + sharedQueue.size());
                            sharedQueue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    int value = sharedQueue.remove(0);
                    System.out.println(Thread.currentThread().getName() + " consumed " + value + ", size: " + sharedQueue.size());
                    sharedQueue.notifyAll();
                }
                sleep(60);
            }
        }
    }
    
    private static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，我们定义了一个 `sharedQueue` 列表作为生产者和消费者之间共享的产品队列。然后我们创建了2个生产者线程和2个消费者线程，并分别启动它们。每个生产者线程都在不断地检查队列的长度和产品容量，如果队列已经达到最大容量，则线程会进入等待状态。当队列有空余空间时，生产者线程生产一些产品并将其添加到队列中，最后唤醒其他所有线程。每个消费者线程也在不断地检查队列的长度并等待，当队列中有产品时，消费者线程消费一些产品，并唤醒其他所有线程。

至于同步机制，我们使用了对象级别的锁，并且每次修改 `sharedQueue` 集合时都指定了同步块。我们还使用了 `wait()` 和 `notifyAll()` 方法来阻塞和唤醒线程，以确保生产者和消费者之间的同步。即使生产者和消费者线程同时访问队列的同一部分，它们也不会出现争用，因为每个线程必须获得共享队列的同步锁才能修改队列。