毕老师在视频中是用while来判断标记的，这样不能控制次数，只能强制程序结束，我想问下有谁能用for循环这种方式重写，这样就既可以判断标记，还可以控制程序运行的次数。

因为每个线程的执行次数是不确定 的，面for循环一般是在明确循环次数的时候用比较合适，所以这里用while比较好了些，再说了这里的while的作用只是让线程每次都去判断一下标记，以防出现两个线程同时挂在判断标记之后，然后再执行时没有判断标记而出现安全问题。

1. class Resource
   
2. {
   
3.           private String name;
   
4.           private int count=1;
   
5.           private boolean flag=false;
   
6.           public synchronized void setName(String name)
   
7.          {
   
8.                         while(flag)
   
9.                              try{this.wait();}catch(Exception e){}//如果这里是if的话,那么线程t1进来后判断然后执行,最后返回来再判断时flag为true,会等在这里,这里t2也进来后,也会挂在这里,然后消费者线程运行,然后再次唤醒线程t1和t2的时候,t2就不用再判断标记,所以会出安全问题所以要用while,可以使t2在执行之前再对标记进行判断
   
10.                         this.name=name+"----"+count++;
    
11.                         System.out.println(Thread.currentThread().getName()+"---shengchan---"+this.name);
    
12.                         flag=true;
    
13.                         this.notifyAll();//这里不仅唤醒了对方,也唤醒 了自己方的,自己方的也会抢夺执行权
    
14.          }
    
15.           public synchronized void out()
    
16.           {
    
17.                   while(!flag)
    
18.                         try{this.wait();}catch(Exception e){}
    
19.                   System.out.println(Thread.currentThread().getName()+"---xiaofei---"+this.name);
    
20.                   flag=false;
    
21.                   this.notifyAll();
    
22.           }
    
23. 
    
24. }
    
25. class Producer implements Runnable
    
26. {
    
27.            private Resource rec;
    
28.            Producer(Resource rec)
    
29.           {
    
30.                    this.rec=rec;
    
31.            }
    
32.            public void run()
    
33.            {
    
34.                     while(true)
    
35.                    {
    
36.                                   rec.setName("shangpin");
    
37.                     }
    
38.              }
    
39. }
    
40. class Consume implements Runnable
    
41. {
    
42.              private Resource rec;
    
43.              Consume(Resource rec)
    
44.             {
    
45.                      this.rec=rec;
    
46.              }
    
47.             public void run()
    
48.            {
    
49.                    while(true)
    
50.                    {
    
51.                            rec.out();
    
52.                     }
    
53.            }
    
54. }
    
55. class ShopDemo
    
56. {
    
57.            public static void main(String[] args)
    
58.          {
    
59.                     Resource r=new Resource();
    
60.                     Producer p=new Producer(r);
    
61.                     Consume c=new Consume(r);
    
62.                     Thread t1=new Thread(p);
    
63.                     Thread t2=new Thread(p);
    
64.                     Thread t3=new Thread(c);
    
65.                     Thread t4=new Thread(c);
    
66.                     t1.start();
    
67.                     t2.start();
    
68.                     t3.start();
    
69.                     t4.start();
    
70.          }
    
71. }
    

复制代码

可以把它改成下面的更方便,其中 Condition将Object监视器方法wait   notify  和notifyAll分解成截然不同的对象，以便通过将这些对象与任意Lock实现组合使用，为每个对象提供多个等待,其中，Lock 替代了synchronized方法和语句的使用，Condition 替代了 Object 监视器方法的使用。

1. import java.util.concurrent.locks.*;
   
2. class Resource
   
3. {
   
4.              private String name;
   
5.              private int count = 1;
   
6.              private boolean flag = false;
   
7.              private Lock lock=new ReentrantLock();//创建一个显式的锁，替代了synchronized
   
8.             Condition condition_pro=lock.newCondition();//Condition 替代了 Object 监视器方法的使用，因为Condition是一个接口，所以要用Lock的newCondition方法来返回一个特定锁的实例，来完成对不同对象提供等待和唤醒
   
9.             Condition condition_con=lock.newCondition();
   
10.              public void set(String name)throws InterruptedException
    
11.            {
    
12.                      lock.lock();
    
13.                      try
    
14.                      {
    
15.                                 while(flag)
    
16.                                       condition_pro.await();
    
17.                                 this.name = name+"--"+count++;
    
18.                                 System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
    
19.                                 flag = true;
    
20.                                  condition_con.signal();//只唤醒消费者线程
    
21.                     }
    
22. 
    
23.                      finally
    
24.                       {
    
25.                                 lock.unlock();//无论判断标记结果如何,或者抛出异常,最后都要释放资源解锁
    
26.                      }
    
27.              public void out()throws InterruptedException
    
28.            {
    
29.                        try
    
30.                         {
    
31.                                   while(!flag)
    
32.                                           condition_con.await();
    
33.                                   System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
    
34.                                    flag = false;
    
35.                                    condition_pro.signal();
    
36.                           }
    
37.                          finally
    
38.                          {
    
39.                                      lock.unlock();
    
40.                           }
    
41. 
    
42.             }
    
43. }
    
44. 
    
45. class Producer implements Runnable
    
46. {
    
47.             private Resource res;
    
48. 
    
49.              Producer(Resource res)
    
50.             {
    
51.                        this.res = res;
    
52.              }
    
53.             public void run()
    
54.            {
    
55.                      while(true)
    
56.                     {
    
57.                             try
    
58.                            {
    
59.                                       res.set("+商品+");
    
60.                             }
    
61.                           catch (InterruptedException e)
    
62.                         {
    
63.                           }
    
64.                  }
    
65. 
    
66.            }
    
67. }
    
68. 
    
69. class Consumer implements Runnable
    
70. {
    
71.               private Resource res;
    
72. 
    
73.              Consumer(Resource res)
    
74.             {
    
75.                           this.res = res;
    
76.             }
    
77.             public void run()
    
78.            {
    
79.                      while(true)
    
80.                    {
    
81.                                   try
    
82.                                 {
    
83.                                             res.out();
    
84.                                 }
    
85.                                catch (InterruptedException e)
    
86.                                {
    
87.                                  }
    
88.                   }
    
89. 
    
90.           }
    
91. }
    
92. class ProducerConsumerDemo
    
93. {
    
94.              public static void main(String[] args)
    
95.               {
    
96.                        Resource r = new Resource();
    
97. 
    
98.                        Producer pro = new Producer(r);
    
99.                         Consumer con = new Consumer(r);
    
100. 
     
101.                          Thread t1 = new Thread(pro);//创建两个生产者线程和两个消费都线程
     
102.                          Thread t2 = new Thread(pro);
     
103.                          Thread t3 = new Thread(con);
     
104.                          Thread t4 = new Thread(con);
     
105. 
     
106.                          t1.start();
     
107.                          t2.start();
     
108.                          t3.start();
     
109.                          t4.start();
     
110. 
     
111.               }
     
112. }
     

复制代码

feigecal 发表于 2012-7-5 08:06
因为每个线程的执行次数是不确定 的，面for循环一般是在明确循环次数的时候用比较合适，所以这里用while比 ...

不好意思啊，格式改好了