class  ProducerConsumerDemo
{
        public static void main(String[] args)
        {
                Resource r = new Resource();
               
                Producer pro = new Producer(r);
                Consumer con = new Consumer(r);

                Thread t1 = new Thread(pro);
                Thread t2 = new Thread(pro);
                Thread t3 = new Thread(con);
                Thread t4 = new Thread(con);

                t1.start();
                t2.start();
                t3.start();
                t4.start();
        }
}
class Resource
{
        private String name;
        private int count = 1;
        private boolean flag = false;

        public synchronized void set(String name)
        {
                while(flag)
                        try
                        {
                                wait();
                        }
                        catch (Exception e)
                        {
                        }
                this.name = name+"---"+count++;
                System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
                flag = true;
                this.notifyAll();//
        }
        public synchronized void out()
        {
                while(!flag)
                        try
                        {
                                wait();
                        }
                        catch (Exception e)
                        {
                        }
                System.out.println(Thread.currentThread().getName()+"...消费者-------"+this.name);
                flag = false;
                this.notifyAll();//
        
        }
}
class Producer implements Runnable
{
        private Resource res;
        Producer(Resource res)
        {
                this.res = res;
        }
        public void run()
        {
                while(true)
                {
                        res.set("+++商品+++");
                }
        }
}
class Consumer implements Runnable
{
        private Resource res;
        Consumer(Resource res)
        {
                this.res = res;
        }
        public void run()
        {
                while(true)
                {
                        res.out();
                }
        }
}
这是毕老师多线程视频中关于“生产消费”的代码，实现生产1件商品，就消费1件商品。
疑问：那怎么实现生产多件商品，消费多件商品呢？其中还会出现什么安全问题？

如果有多件商品的产生和消费，可以阻塞队列来实现
1，阻塞队列可以设置长度
2，阻塞队列take方法：获取元素，如果队列是空的则阻塞直到不空
3，阻塞队列put方法：添加元素，如果队列已满则阻塞直到不满
代码如下：

1. import java.util.concurrent.BlockingQueue;
   
2. import java.util.concurrent.LinkedBlockingQueue;
   
3. 
   
4. class ProducerConsumerDemo {
   
5.     public static void main(String[] args) {
   
6.         
   
7.         // 设置队列的最大长度
   
8.         final int MAX_RESOURCE_COUNT = 10;
   
9.         
   
10.         // 生产者和消息者共享的阻塞队列
    
11.         BlockingQueue<Resource> queue = new LinkedBlockingQueue<Resource>(MAX_RESOURCE_COUNT);
    
12. 
    
13.         Producer pro = new Producer(queue);
    
14.         Consumer con = new Consumer(queue);
    
15. 
    
16.         Thread t1 = new Thread(pro);
    
17.         Thread t2 = new Thread(pro);
    
18.         Thread t3 = new Thread(con);
    
19.         Thread t4 = new Thread(con);
    
20. 
    
21.         t1.start();
    
22.         t2.start();
    
23.         t3.start();
    
24.         t4.start();
    
25.     }
    
26. }
    
27. 
    
28. class Resource {
    
29.     private int id = generator++;
    
30.     private static int generator = 0;
    
31.     public int getId(){
    
32.         return id;
    
33.     }
    
34. }
    
35. 
    
36. class Producer implements Runnable {
    
37.     private BlockingQueue<Resource> queue;
    
38. 
    
39.     Producer(BlockingQueue<Resource> queue) {
    
40.         this.queue = queue;
    
41.     }
    
42. 
    
43.     public void run() {
    
44.         while (true) {
    
45.             Resource resource = new Resource();
    
46.             try {
    
47.                 // 向共享队列中添加资源，如果队列已满则阻塞直到不满
    
48.                 queue.put(resource);
    
49.                 System.out.println("生产者：" + Thread.currentThread().getName()+ " ，队列大小：" + queue.size() + "，生产："+ resource.getId());
    
50.             } catch (InterruptedException e) {
    
51.                 e.printStackTrace();
    
52.             }
    
53.         }
    
54.     }
    
55. }
    
56. 
    
57. class Consumer implements Runnable {
    
58.     private BlockingQueue<Resource> queue;
    
59. 
    
60.     Consumer(BlockingQueue<Resource> queue) {
    
61.         this.queue = queue;
    
62.     }
    
63. 
    
64.     public void run() {
    
65.         while (true) {
    
66.             try {
    
67.                 // 从共享队列中获取资源，如果队列是空的则阻塞直到不空
    
68.                 Resource resource = queue.take();
    
69.                 System.out.println("消息者：" + Thread.currentThread().getName()+ " ，队列大小：" + queue.size() + "，消费："+ resource.getId());
    
70.             } catch (InterruptedException e) {
    
71.                 e.printStackTrace();
    
72.             }
    
73.         }
    
74.     }
    
75. }

复制代码

其实问题很简单，在毕老师代码中主函数的地方Resource r = new Resource();这就是像是建立了车间，你建立2个3个车间或者更多，这样就有多个资源对象，那么就能一次产生多个商品，比如一个资源对象对应一个生产者消费者，多个对应多个生产者消费者，那么宏观上感觉是不是就是一次生产了多个消费了多个；

记得及时处理帖子，继续追问；或将分类改成【已解决】~