java多线程wait时为什么要用while而不是if

转载：https://blog.csdn.net/worldchinalee/article/details/83790790

说下结论：就是用if判断的话，唤醒后线程会从wait之后的代码开始运行，但是不会重新判断if条件，直接继续运行if代码块之后的代码，而如果使用while的话，也会从wait之后的代码运行，但是唤醒后会重新判断循环条件，如果不成立再执行while代码块之后的代码块，成立的话继续wait。

对于java多线程的wait（）方法，我们在jdk1.6的说明文档里可以看到这样一段话

 

从上面的截图，我们可以看出，在使用wait方法时，需要使用while循环来判断条件十分满足，而不是if，那么我们思考以下，如果使用if会怎么样？

为方便讲解，我们来看一个被广泛使用的生产消费的例子。代码部分参考  郝斌java视频教程  部分改编。

1.  
   /*
2.  
   生产和消费
3.  
   */
4.  
   package multiThread;
5.  
    
6.  
   class SynStack
7.  
   {
8.  
   private char[] data = new char[6];
9.  
   private int cnt = 0; //表示数组有效元素的个数
10.  
     
11.  
    public synchronized void push(char ch)
12.  
    {
13.  
    if (cnt >= data.length)
14.  
    {
15.  
    try
16.  
    {
17.  
    System.out.println("生产线程"+Thread.currentThread().getName()+"准备休眠");
18.  
    this.wait();
19.  
    System.out.println("生产线程"+Thread.currentThread().getName()+"休眠结束了");
20.  
    }
21.  
    catch (Exception e)
22.  
    {
23.  
    e.printStackTrace();
24.  
    }
25.  
    }
26.  
    this.notify();
27.  
    data[cnt] = ch;
28.  
    ++cnt;
29.  
    System.out.printf("生产线程"+Thread.currentThread().getName()+"正在生产第%d个产品，该产品是: %c\n", cnt, ch);
30.  
    }
31.  
     
32.  
    public synchronized char pop()
33.  
    {
34.  
    char ch;
35.  
    if (cnt <= 0)
36.  
    {
37.  
    try
38.  
    {
39.  
    System.out.println("消费线程"+Thread.currentThread().getName()+"准备休眠");
40.  
    this.wait();
41.  
    System.out.println("消费线程"+Thread.currentThread().getName()+"休眠结束了");
42.  
    }
43.  
    catch (Exception e)
44.  
    {
45.  
    e.printStackTrace();
46.  
    }
47.  
    }
48.  
    this.notify();
49.  
    ch = data[cnt-1];
50.  
    System.out.printf("消费线程"+Thread.currentThread().getName()+"正在消费第%d个产品，该产品是: %c\n", cnt, ch);
51.  
    --cnt;
52.  
    return ch;
53.  
    }
54.  
    }
55.  
     
56.  
    class Producer implements Runnable
57.  
    {
58.  
    private SynStack ss = null;
59.  
    public Producer(SynStack ss)
60.  
    {
61.  
    this.ss = ss;
62.  
    }
63.  
     
64.  
    public void run()
65.  
    {
66.  
    char ch;
67.  
    for (int i=0; i<10; ++i)
68.  
    {
69.  
    // try{
70.  
    // Thread.sleep(100);
71.  
    // }
72.  
    // catch (Exception e){
73.  
    // }
74.  
     
75.  
    ch = (char)('a'+i);
76.  
    ss.push(ch);
77.  
    }
78.  
    }
79.  
    }
80.  
     
81.  
    class Consumer implements Runnable
82.  
    {
83.  
    private SynStack ss = null;
84.  
     
85.  
    public Consumer(SynStack ss)
86.  
    {
87.  
    this.ss = ss;
88.  
    }
89.  
     
90.  
    public void run()
91.  
    {
92.  
    for (int i=0; i<10; ++i)
93.  
    {
94.  
    /*try{
95.  
    Thread.sleep(100);
96.  
    }
97.  
    catch (Exception e){
98.  
    }*/
99.  
     
100.  
     //System.out.printf("%c\n", ss.pop());
101.  
     ss.pop();
102.  
     }
103.  
     }
104.  
     }
105.  
      
106.  
      
107.  
     public class TestPC2
108.  
     {
109.  
     public static void main(String[] args)
110.  
     {
111.  
     SynStack ss = new SynStack();
112.  
     Producer p = new Producer(ss);
113.  
     Consumer c = new Consumer(ss);
114.  
      
115.  
      
116.  
     Thread t1 = new Thread(p);
117.  
     t1.setName("1号");
118.  
     t1.start();
119.  
     /*Thread t2 = new Thread(p);
120.  
     t2.setName("2号");
121.  
     t2.start();*/
122.  
      
123.  
     Thread t6 = new Thread(c);
124.  
     t6.setName("6号");
125.  
     t6.start();
126.  
     /*Thread t7 = new Thread(c);
127.  
     t7.setName("7号");
128.  
     t7.start();*/
129.  
     }
130.  
     }

上面的代码只有一个消费者线程和一个生产者线程，程序运行完美，没有任何错误，那为为什么jdk里面强调要用while呢？

这个问题，我之前也向了很久，同事提到了一点，这个程序如果用到多个生产者和消费者的情况，就会出错，我试了一下，确实会出错。但是我不能明白为什么就会出错。

不是有synchronized关键字加锁了吗？

其实，这里也错在我对wait方法原理的实际运行效果不是很了解，当我在wait方法的前后都加上输出提示语句后，我明白了。

一个线程执行了wait方法以后，它不会再继续执行了，直到被notify唤醒。

那么唤醒以后从何处开始执行？

这是解决这里出错原因的关键。

我们尝试修改代码，实现一个生产线程，两个消费线程。

1.  
   /*
2.  
   生产和消费
3.  
   */
4.  
   package multiThread;
5.  
    
6.  
   class SynStack
7.  
   {
8.  
   private char[] data = new char[6];
9.  
   private int cnt = 0; //表示数组有效元素的个数
10.  
     
11.  
    public synchronized void push(char ch)
12.  
    {
13.  
    if (cnt >= data.length)
14.  
    {
15.  
    try
16.  
    {
17.  
    System.out.println("生产线程"+Thread.currentThread().getName()+"准备休眠");
18.  
    this.wait();
19.  
    System.out.println("生产线程"+Thread.currentThread().getName()+"休眠结束了");
20.  
    }
21.  
    catch (Exception e)
22.  
    {
23.  
    e.printStackTrace();
24.  
    }
25.  
    }
26.  
    this.notify();
27.  
    data[cnt] = ch;
28.  
    ++cnt;
29.  
    System.out.printf("生产线程"+Thread.currentThread().getName()+"正在生产第%d个产品，该产品是: %c\n", cnt, ch);
30.  
    }
31.  
     
32.  
    public synchronized char pop()
33.  
    {
34.  
    char ch;
35.  
    if (cnt <= 0)
36.  
    {
37.  
    try
38.  
    {
39.  
    System.out.println("消费线程"+Thread.currentThread().getName()+"准备休眠");
40.  
    this.wait();
41.  
    System.out.println("消费线程"+Thread.currentThread().getName()+"休眠结束了");
42.  
    }
43.  
    catch (Exception e)
44.  
    {
45.  
    e.printStackTrace();
46.  
    }
47.  
    }
48.  
    this.notify();
49.  
    ch = data[cnt-1];
50.  
    System.out.printf("消费线程"+Thread.currentThread().getName()+"正在消费第%d个产品，该产品是: %c\n", cnt, ch);
51.  
    --cnt;
52.  
    return ch;
53.  
    }
54.  
    }
55.  
     
56.  
    class Producer implements Runnable
57.  
    {
58.  
    private SynStack ss = null;
59.  
    public Producer(SynStack ss)
60.  
    {
61.  
    this.ss = ss;
62.  
    }
63.  
     
64.  
    public void run()
65.  
    {
66.  
    char ch;
67.  
    for (int i=0; i<10; ++i)
68.  
    {
69.  
    // try{
70.  
    // Thread.sleep(100);
71.  
    // }
72.  
    // catch (Exception e){
73.  
    // }
74.  
     
75.  
    ch = (char)('a'+i);
76.  
    ss.push(ch);
77.  
    }
78.  
    }
79.  
    }
80.  
     
81.  
    class Consumer implements Runnable
82.  
    {
83.  
    private SynStack ss = null;
84.  
     
85.  
    public Consumer(SynStack ss)
86.  
    {
87.  
    this.ss = ss;
88.  
    }
89.  
     
90.  
    public void run()
91.  
    {
92.  
    for (int i=0; i<10; ++i)
93.  
    {
94.  
    /*try{
95.  
    Thread.sleep(100);
96.  
    }
97.  
    catch (Exception e){
98.  
    }*/
99.  
     
100.  
     //System.out.printf("%c\n", ss.pop());
101.  
     ss.pop();
102.  
     }
103.  
     }
104.  
     }
105.  
      
106.  
      
107.  
     public class TestPC2
108.  
     {
109.  
     public static void main(String[] args)
110.  
     {
111.  
     SynStack ss = new SynStack();
112.  
     Producer p = new Producer(ss);
113.  
     Consumer c = new Consumer(ss);
114.  
      
115.  
      
116.  
     Thread t1 = new Thread(p);
117.  
     t1.setName("1号");
118.  
     t1.start();
119.  
     /*Thread t2 = new Thread(p);
120.  
     t2.setName("2号");
121.  
     t2.start();*/
122.  
      
123.  
     Thread t6 = new Thread(c);
124.  
     t6.setName("6号");
125.  
     t6.start();
126.  
     Thread t7 = new Thread(c);
127.  
     t7.setName("7号");
128.  
     t7.start();
129.  
     }
130.  
     }

上面代码就是在main函数里增加了一个消费线程。

然后错误出现了。

数组越界，为什么会这样？

问题的关键就在于7号消费线程唤醒了6号消费线程，而6号消费线程被唤醒以后，它从哪里开始执行是关键！！！！

它会执行

System.out.println("消费线程"+Thread.currentThread().getName()+"休眠结束了");

这行代码。

不是从pop()方法的开始处执行。

那么这跟使用if方法有什么关系？

因为，7号线程唤醒了6号线程，并执行了以下4行代码。

1.  
   ch = data[cnt-1];
2.  
   System.out.printf("消费线程"+Thread.currentThread().getName()+"正在消费第%d个产品，该产品是: %c\n", cnt, ch);
3.  
   --cnt;
4.  
   return ch;

7号线程执行完上面的代码后，cnt就=0了

　　又因为6号线程被唤醒时已经处在if方法体内，它不会再去执行if条件判断，所以就顺序往下执行，这个时候执行

ch = data[cnt-1];<br>就会出现越界异常。<br>假如使用while就不会，因为当唤醒了6号线程以后，它依然会去执行循环条件检测。所以不可能执行下去，保证了程序的安全。<br><br><br>

结论：就是用if判断的话，唤醒后线程会从wait之后的代码开始运行，但是不会重新判断if条件，直接继续运行if代码块之后的代码，而如果使用while的话，也会从wait之后的代码运行，但是唤醒后会重新判断循环条件，如果不成立再执行while代码块之后的代码块，成立的话继续wait。