多线程中，线程wait方法抛出异常后，就释放了锁进入了临时堵塞状态，当该线程被唤醒以后，为什么还要去判断while语句的参数呢？wait方法不是在while语句内吗，应该是唤醒后继续往下运行撒

重点在于：被唤醒以后为什么还会去判断while语句条件，先不是已经判断过了吗？难道不是应该继续向下执行吗？

求高人指点，在线坐等！

哥们，不知道你是指的哪一个例子；
比如：生产者消费者那个例子，循环判断是为了保证不产生数据错乱，

         

1. //如下定义了一个产品类，产品类有自己的属性,然后创建了两个Runnable线
   
2. //程类，一个为生产者Producer和消费者Consumer，这两个类持有了对产品类
   
3. //的引用，可以方法和操作产品类对象的属性，达到生产者在刷新产品的属性，//模仿了产品生产的过程，而消费者便可以取得产品的信息，模仿了产
   
4. //品被消费的过程。
   
5. packagecom.thread;
   
6. public classProducerAndConsumer
   
7. {
   
8.        public static void main(String[] args)
   
9.        {
   
10.               Product p = new Product();
    
11.         Producer pr = new Producer(p);
    
12.         Consumer cr = new Consumer(p);
    
13.         Thread t1 = new Thread(pr);
    
14.         Thread t2 = new Thread(pr);
    
15.         Thread t3 = new Thread(cr);
    
16.         Thread t4 = new Thread(cr);
    
17.         t1.start();
    
18.         t2.start();
    
19.         t3.start();
    
20.         t4.start();
    
21.        }
    
22. }
    
23. //定一个产品类
    
24. class Product
    
25. {
    
26.         private String name;
    
27.         private int ID = 1;
    
28.         public boolean flag = false;
    
29.      public synchronized void  setProperty(String name)
    
30.         {
    
31.                                     while(flag)
    
32.                                    {
    
33.                                                 try
    
34.                                                 {
    
35.                                                        this.wait();
    
36.                                                 }
    
37.                                                     catch(Exception e)
    
38.                                                 {
    
39.                                                 };
    
40.                                    }
    
41. this.name =name+" "+ID++;
    
42. System.out.println(Thread.currentThread().getName()+" 生产出 "+this.name);
    
43.                                                         flag = true;
    
44.                                                         this.notifyAll();
    
45.         }
    
46.      public synchronized void getInfo()
    
47.      {
    
48. //这里使用Wlile而不是if实用为while会条件会被判断两次，不会到一个产品被//消费两次，或程序挂起的状况。
    
49.                         while(!flag)
    
50.                         {
    
51.                                                try
    
52.                                                {
    
53.                                                       this.wait();
    
54.                                                }
    
55.                                                    catch(Exception e)
    
56.                                                {
    
57.                                                };
    
58.                         }
    
59. System.out.println(Thread.currentThread().getName()+" 消费了 "+this.name+" o(∩_∩)o...哈哈！！！");
    
60.                                         flag = false;
    
61. //这里notifyAll()是为了防止之唤醒本对列的线程，却没有唤醒对方的线程，最
    
62. //终导致程序都进入wait状态，程序挂起。
    
63.                                         this.notifyAll();
    
64.      }
    
65. }
    
66. 
    
67. class Producer implements Runnable
    
68. {
    
69.           private Product p;
    
70.           public Producer(Product p)
    
71.           {
    
72.                  this.p = p;
    
73.           }
    
74.           @Override
    
75.           public void run()
    
76.           {
    
77.                 while(true)
    
78.                 {
    
79.                         p.setProperty("糖果");
    
80.                 }
    
81.               
    
82.           }
    
83. }
    
84. 
    
85. class Consumer implements Runnable
    
86. {
    
87.          private Product p ;
    
88.          publicConsumer(Product p)
    
89.          {
    
90.                this.p = p;
    
91.          }
    
92.          @Override
    
93.        public void run()
    
94.        {
    
95.                while(true)
    
96.                {
    
97.                                    p.getInfo();
    
98.                }
    
99.        }
    
100. }

复制代码

你可以将wait语句看成普通语句，它在while语句中，当它运行完了的时候当然要去while内进行语句判断呀！
希望对你有所帮助!!!!!