1. public class ProducerConsumerDemo {
   
2. 
   
3.         public static void main(String[] args){
   
4.                 Resource r = new Resource();
   
5.                
   
6.                 Producer pro = new Producer(r);
   
7.                 Consumer con = new Consumer(r);
   
8. 
   
9.                 Thread t1 = new Thread(pro);
   
10.                 Thread t2 = new Thread(con);
    
11. 
    
12.                 t1.start();
    
13.                 t2.start();
    
14.         }
    
15. }
    
16. 
    
17. class Resource{
    
18.         
    
19.         private String name;
    
20.         private int count = 1;
    
21.         private boolean flag = false;
    
22.         
    
23.         public synchronized void set(String name){
    
24.                 if(flag)
    
25.                         try {
    
26.                                 this.wait();
    
27.                         } catch (InterruptedException e) {
    
28.                                 e.printStackTrace();
    
29.                         }
    
30.                 this.name = name + "--" + count++;
    
31.                 System.out.println(Thread.currentThread().getName() + "--producer--" + this.name);
    
32.                 flag = true;
    
33.                 this.notify();
    
34.         }
    
35.         
    
36.         public synchronized void out(){
    
37.                 if(!flag)
    
38.                         try {
    
39.                                 wait();
    
40.                         } catch (InterruptedException e) {
    
41.                                 e.printStackTrace();
    
42.                         }
    
43.                 System.out.println(Thread.currentThread().getName() + "--consumer---------------" + this.name);
    
44.                 flag = false;
    
45.                 notify();
    
46.         }
    
47. }
    
48. 
    
49. class Producer implements Runnable{
    
50.         private Resource r;
    
51.         
    
52.         public Producer(Resource r){
    
53.                 this.r = r;
    
54.         }
    
55.         
    
56.         public void run(){
    
57.                 while(true){
    
58.                         r.set("conduct");
    
59.                 }
    
60.         }
    
61. }
    
62. 
    
63. class Consumer implements Runnable{
    
64.         private Resource r;
    
65.         
    
66.         public Consumer(Resource r){
    
67.                 this.r = r;
    
68.         }
    
69.         public void run(){
    
70.                 r.out();
    
71.         }
    
72. }

复制代码

运行结果为

1. Thread-0--producer--conduct--1
   
2. Thread-1--consumer---------------conduct--1
   
3. Thread-0--producer--conduct--2

复制代码

这是什么问题卡住了？应该是两个线程交替出现啊

明白了，太粗心了。感谢各位

我也正在学这里。这是我的代码。可以参考参考。嘿嘿。有机会一起交流

1. 
   
2. 
   
3. 
   
4. //producer：生产者，制片人        consumer：消费者，用户
   
5. class ProducerConsumerDemo
   
6. {
   
7.         public static void main(String[] args)
   
8.         {
   
9.                 //创建resource对象
   
10.                 Resource res = new Resource();
    
11.                 //创建producer对象
    
12.                 Producer pro = new Producer(res);
    
13.                 //创建Consumer对象
    
14.                 Consumer con = new Consumer(res);
    
15.                 //创建4个线程
    
16.                 Thread t1 = new Thread(pro);
    
17.                 Thread t2 = new Thread(con);
    
18.                 Thread t3 = new Thread(pro);
    
19.                 Thread t4 = new Thread(con);
    
20.                 //启动四个线程
    
21.                 t1.start();
    
22.                 t2.start();
    
23.                 t3.start();
    
24.                 t4.start();
    
25.         }
    
26. }
    
27. 
    
28. //resource:资源
    
29. class Resource
    
30. {
    
31.         //私有的产品名称
    
32.         private String name;
    
33.         //私有的计数器，产品编号
    
34.         private int count = 1;
    
35.         //布尔型变量,用于判断线程要执行哪里
    
36.         private boolean flag = false;
    
37.         
    
38.         //加同步锁的set，设置产品名称的方法。
    
39.         public synchronized void set(String name)
    
40.         {
    
41.                 while(true)
    
42.                 {
    
43.                         //判断flag是否真
    
44.         //                if (flag)
    
45.                         //while循环判断,当线程被解除冻结后需要回来再判断一次
    
46.                         while (flag)
    
47. 
    
48.                         {
    
49.                                 //wait：等待，把当前线程冻结起来。等待notify（通知，告知）唤醒，notifyAll：唤醒全部线程
    
50.                                 try{wait();}catch(Exception e){}
    
51.                         }
    
52.                         //把传入的name加上计数器赋值给本类的name
    
53.                         this.name = name+"+==+"+count++;
    
54. 
    
55.                         //打印当前线程name和当前生产者的name
    
56.                         System.out.println(Thread.currentThread().getName()+".生产者.SS."+this.name);
    
57.                         //把flag的值改为true。
    
58.                         flag = true;
    
59.                         //唤醒第一个冻结的线程
    
60.         //                this.notify();
    
61.                         //唤醒所有线程
    
62.                         this.notifyAll();
    
63.                 }
    
64.         }
    
65. 
    
66.         //输出函数，输出产品名称和编号
    
67.         public synchronized void out()
    
68.         {
    
69.                 while(true)
    
70.                 {
    
71.                         //if判断flag是否为false,线程被唤醒后继续执行，不再回来判断
    
72.         //                if (!flag)
    
73.                         //while循环判断,当线程被解除冻结后需要回来再判断一次
    
74.                         while (!flag)
    
75.                         {
    
76.                                 //flag为false时，线程进入等待状态，没有执行资格，等待唤醒
    
77.                                 try{wait();}catch(Exception e){}
    
78.                         }
    
79.                         //打印当前线程名称和购买者名称
    
80.                         System.out.println(Thread.currentThread().getName()+".购买者.GOGOGO."+this.name);
    
81.                         //修改flag的值为false；
    
82.                         flag = false;;
    
83.                         //唤醒最先冻结的线程
    
84.         //                this.notify();
    
85.                         //唤醒所有线程
    
86.                         this.notifyAll();
    
87.                 }
    
88.         }
    
89. }
    
90. 
    
91. //创建类producer，实现多线程Runnable接口。
    
92. class Producer implements Runnable
    
93. {
    
94.         //建立resource引用
    
95.         private Resource res;
    
96.         //初始化引用
    
97.         Producer(Resource res)
    
98.         {
    
99.                 //把引用指向类resource
    
100.                 this.res = res;
     
101.         }
     
102.         
     
103.         //复写run方法
     
104.         public void run()
     
105.         {
     
106. //                while(true)
     
107. //                {
     
108.                         //调用set函数，对产品名称进行设置
     
109.                         res.set("雀氏挖掘机");
     
110. //                }
     
111.         }
     
112. 
     
113. }
     
114. 
     
115. class Consumer implements Runnable
     
116. {
     
117.         //建立引用
     
118.         private Resource res;
     
119.         //初始化
     
120.         Consumer(Resource res)
     
121.         {
     
122.                 //res赋值
     
123.                 this.res = res;
     
124.         }
     
125. 
     
126.         //复写run函数
     
127.         public void run()
     
128.         {
     
129. //                while(true)
     
130. //                {
     
131.                         //调用out函数。
     
132.                         res.out();
     
133. //                }
     
134.         }
     
135. }

复制代码

楼上终结

Consumer 方法中
r.out()没有循环,只运行了一次

public void run()
{
       r.out();//这里消费者你没有循环啊，当然只消费一次咯
  }

你给的结果不是交替了么？

自己顶一顶，现在还没想通啊，有大神知道吗？