Java中wait()和notify()方法的使用

1. wait方法和notify方法

這兩個方法，包括notifyAll方法，都是Object類中的方法。在Java API中，wait方法的定義如下：

public final void wait()
                throws InterruptedException

Causes the current thread to wait until another thread invokes the notify() method or the notifyAll() method for this object. In other words, this method behaves exactly as if it simply performs the call wait(0).

The current thread must own this object's monitor. The thread releases ownership of this monitor and waits until another thread notifies threads waiting on this object's monitor to wake up either through a call to the notify method or the notifyAll method. The thread then waits until it can re-obtain ownership of the monitor and resumes execution.

As in the one argument version, interrupts and spurious wakeups are possible, and this method should always be used in a loop:

     synchronized (obj) {
         while (<condition does not hold>)
             obj.wait();
         ... // Perform action appropriate to condition
     }
 

This method should only be called by a thread that is the owner of this object's monitor. See the notify method for a description of the ways in which a thread can become the owner of a monitor.

在 Java 中可以用 wait、notify 和 notifyAll 來實現線程間的通信。線程在運行的時候，如果發現某些條件沒有被滿足，可以調用wait方法暫停自己的執行，並且放棄已經獲得的鎖，然后進入等待狀態。當該線程被其他線程喚醒並獲得鎖后，可以沿着之前暫停的地方繼續向后執行，而不是再次從同步代碼塊開始的地方開始執行。但是需要注意的一點是，對線程等待的條件的判斷要使用while而不是if來進行判斷。這樣在線程被喚醒后，會再次判斷條件是否正真滿足。

想象一下一個生產者，多個消費者的場景。一個消費者Consumer1了最后一個元素，並且喚醒了其他線程，如果被喚醒的正好是Consumer2，那么此時是沒有元素可以消費的。如果用的是if判斷，那么被喚醒后就不會再次進行條件的判斷，而是直接向下執行導致運行錯誤。我們的代碼如下：

notify方法會喚醒等待一個對象鎖的線程，但是具體喚醒哪個是不確定的。

 

2. 實現生產者消費者

如下使用if來判斷會導致程序出錯

一定要使用while來進行判斷線程的等待條件而不是使用if

package thread.learn;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;

/**
 * Created by liujinhong on 2017/4/2.
 * 生產者消費者問題是一個很經典的問題，值得好好研究一下
 * java的wait和notify方法在使用時也是要非常注意的
 */
public class ProducerConsumer {
    public static class Producer extends Thread {
        Queue<Integer> queue;
        int maxsize;

        Producer(Queue<Integer> queue, int maxsize, String name) {
            this.queue = queue;
            this.maxsize = maxsize;
            this.setName(name);
        }
        @Override
        public void run() {
            while (true) {
                synchronized (queue) {
                    try{
                        Thread.sleep(500);
                    } catch (Exception e) {}

                    System.out.println(this.getName() + "獲得隊列的鎖");
                    //條件的判斷一定要使用while而不是if
                    if (queue.size() == maxsize) {
                        System.out.println("隊列已滿，生產者" + this.getName() + "等待");
                        try {
                            queue.wait();
                        } catch (Exception e) {}
                    }
                    int num = (int)(Math.random()*100);
                    queue.offer(num);

                    System.out.println(this.getName() + "生產一個元素：" + num);
                    queue.notifyAll();

                    System.out.println(this.getName() + "退出一次生產過程！");
                }
            }
        }
    }

    public static class Consumer extends Thread {
        Queue<Integer> queue;
        int maxsize;

        Consumer(Queue<Integer> queue, int maxsize, String name) {
            this.queue = queue;
            this.maxsize = maxsize;
            this.setName(name);
        }

        @Override
        public void run() {
            while (true) {
                synchronized (queue) {
                    try{
                        Thread.sleep(500);
                    } catch (Exception e) {}

                    System.out.println(this.getName() + "獲得隊列的鎖");
                    //條件的判斷一定要使用while而不是if
                    if (queue.isEmpty()) {
                        System.out.println("隊列為空，消費者" + this.getName() + "等待");
                        try{
                            queue.wait();
                        } catch (Exception e) {}
                    }
                    int num = queue.poll();
                    System.out.println(this.getName() + "消費一個元素："+num);
                    queue.notifyAll();

                    System.out.println(this.getName() + "退出一次消費過程！");
                }
            }
        }
    }

    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        int maxsize = 2;

        Producer producer = new Producer(queue, maxsize, "Producer");
        Consumer consumer1 = new Consumer(queue, maxsize,"Consumer1");
        Consumer consumer2 = new Consumer(queue, maxsize,"Consumer2");
        Consumer consumer3 = new Consumer(queue, maxsize,"Consumer3");

        producer.start();
        consumer1.start();
        consumer2.start();
        consumer3.start();
    }
}