如何为替代生产者和消费者方法编写Java多线程代码。它应该有3个生产者（P1、P2、P3）和1个消费者（C1）

我能得到一个明确的方法来实现这一点吗。我已经使用了join和wait来替代生产者和消费者执行。这个问题是在一次采访中提出的。他不喜欢我的解决方案。我还建议在同步块中使用循环来消耗/生成资源

以下是预期产出：

p1 c1 p3 c1 p2 c1 p2 c1 . .

---

.

以上生产者-消费者实现正在使用等待和通知。非常好的bro。非常感谢你！！但您正在创建对象类实例并将该对象锁定在同步对象中。为什么呢？我们可以使用当前的类对象来实现这一点吗？是的，我认为这是更好的方法。我使用的不是对象类obj，而是具有相同行为的对象类。如果我错了，请纠正我。

import java.util.concurrent.atomic.AtomicInteger;

public class TestClient {

    public static void main(String[] args) {

        ProducerConsumerUtilClass pcuc=new ProducerConsumerUtilClass();

        Thread producer1= new Thread(new Runnable() {

            @Override
            public void run() {
                while(true) {
                    try {
                        Thread.sleep(1000);
                        pcuc.produce();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }

                }

            }
        });

Thread producer2= new Thread(new Runnable() {

            @Override
            public void run() {
                while(true) {
                    try {
                        Thread.sleep(1000);
                        pcuc.produce();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }

                }

            }
        });
Thread producer3= new Thread(new Runnable() {

    @Override
    public void run() {
        while(true) {
            try {
                Thread.sleep(1000);
                pcuc.produce();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }

    }
});


Thread consumer1= new Thread(new Runnable() {

@Override
public void run() {
    while(true) {
        try {
            Thread.sleep(1000);
            pcuc.consume();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}
});

        producer1.start();
        producer2.start();
        producer3.start();
        consumer1.start();



    }

}

 class ProducerConsumerUtilClass {

    Object obj= new Object();
    private volatile boolean  available;
    private AtomicInteger atomicInteger=null;

    public ProducerConsumerUtilClass() {
        this.available = false;;
        this.atomicInteger = new AtomicInteger(0);;
    }

    public void produce() {
        synchronized (obj) {
                while(available) {
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
                System.out.println("Produce By "+Thread.currentThread().getName()+"Value "+atomicInteger.getAndIncrement());
                this.available=true;
                obj.notifyAll();
        }

    }   

    public void consume() {
        synchronized (obj) {
                while(!available) {
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
                System.out.println("Consume By "+Thread.currentThread().getName()+"Value "+atomicInteger.getAndIncrement());
                this.available=false;
                obj.notifyAll();
        }

    }   


}