java线程的等待与通知

线程的等待与通知

wait()函数

使用的时候要注意，要调用共享变量对象的wait()方法，必须先获取该对象的Monitor。否则会抛出IllegalMonitorStateException；

当调用一个共享变量的wait()方法时，该调用线程会被阻塞挂起，直到：1）其他线程调用了该共享变量的notify()或notifyAll()方法；2）其他线程调用了该线程的interrupt()方法，该线程抛出InterruptedException异常返回。

import java.util.PriorityQueue;

import com.tim.base.easystart.util.VeDate;

/**
 * 1, wait使用之前需要获取到操作对象的Monitor
 * 2, wait之后会释放锁定的Monitor
 * 3, notifyAll会唤醒等待该对象的Monitor的所有线程，具体谁来获取到这个Monior是随机的
 */
public class WaitTest {
	
	static PriorityQueue<String> queue=new PriorityQueue<String>();  
	
	public static void add(String content) throws InterruptedException {
		synchronized (queue) {
			while (queue.size() > 10) {
				System.out.println("The Queue is Over 10...");
				queue.wait();
			}
			queue.add(content);
			queue.notifyAll();
		}
	}
	
	public static String getQueue() {
		synchronized (queue) {
			while (queue.size() == 0) {
				try {
					System.out.println("The Queue is Empty...");
					queue.wait();
				} 
				catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			String result = queue.poll();
			queue.notifyAll();
			return result;
		}
	}
	
	public static void main(String[] args) {
		
		Thread t1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				while(true) {
					try {
						add(VeDate.getNo(5));
					} 
					catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				
			}
		});
		
		Thread t2 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				while(true) {
					System.out.println(getQueue());
				}
			}
		});
		
		t1.start();
		
		t2.start();
		
	}
	
}

//附上工具方法
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;

public final class VeDate {

    private VeDate() {

    }

    /**
     * 根据用户传入的时间表示格式，返回当前时间的字符串
     * @param sformat
     *                  yyyyMMddhhmmss
     * @return
     */
    public static String getUserDate(String sformat) {
        Date currentTime = new Date();
        SimpleDateFormat formatter = new SimpleDateFormat(sformat);
        String dateString = formatter.format(currentTime);
        return dateString;
    }

    /**
     * 生成格式为yyyymmddhhmmss+k位随机数
     *
     * @param k
     *            表示是取几位随机数，可以自己定
     * @return
     */

    public static String getNo(int k) {
        return getUserDate("yyyyMMddHHmmss") + getRandom(k);
    }

    /**
     * 返回一个随机数
     *
     * @param i
     * @return
     */
    public static String getRandom(int i) {
        Random jjj = new Random();
        if (i == 0) {
            return "";
        }
        StringBuffer jj = new StringBuffer();
        for (int k = 0; k < i; k++) {
            jj.append(jjj.nextInt(9));
        }
        return jj.toString();
    }

}

wait()方法的常见使用方式：

synchronized (obj) {
	whie(条件不满足) {
        obj.wait();
    }
}

不使用while来判断条件，可能会出现虚假唤醒，关于虚假唤醒可以点击查看wait()-虚假唤醒

当前线程调用共享变量的wait()方法之后，只会释放当前共享变量上的锁，如果当前线程还持有其他共享变量的锁，则这些锁是不会被释放的。

wait()函数调用后被打断

public class WaitInterrupt {

	public static Object obj = new Object();
	
	public static void main(String[] args) throws InterruptedException {
		
		Thread thread = new Thread(new Runnable() {
			
			@Override
			public void run() {
				System.out.println("thread run begin");
				synchronized (obj) {
					try {
						obj.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				System.out.println("thread run end");
			}
		});
		
		thread.start();
		
		Thread.sleep(1000);
		
		System.out.println("Interrupt start");
		thread.interrupt();
		System.out.println("Interrupt end");
	}
	
}

wait(long timeout)和wait(long timeout, int nanos)

wait(long timeout)比wait()函数多了一个超时参数，如果一个线程调用共享对象的wait(long timeout)方法后，没有在timeout ms时间内，被其它线程调用该变量的notify()或notifyAll()方法唤醒，那么函数还是会因为超时而返回。

timeout设置为0效果等同于wait();

    public final void wait() throws InterruptedException {
        wait(0);
    }

timeout设置小于0会抛出IllegalArgumentException异常

   /**
     * @param      timeout   the maximum time to wait in milliseconds.
     * @throws  IllegalArgumentException      if the value of timeout is
     *               negative.
     * @throws  IllegalMonitorStateException  if the current thread is not
     *               the owner of the object's monitor.
     * @throws  InterruptedException if any thread interrupted the
     *             current thread before or while the current thread
     *             was waiting for a notification.  The <i>interrupted
     *             status</i> of the current thread is cleared when
     *             this exception is thrown.
     * @see        java.lang.Object#notify()
     * @see        java.lang.Object#notifyAll()
     */
    public final native void wait(long timeout) throws InterruptedException;

wait(long timeout, int nanos)

    public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos > 0) {
            timeout++;
        }

        wait(timeout);
    }

notify()

一个线程调用共享对象的notify()方法之后，会唤醒一个在该共享变量上调用wait系列方法后被挂起的线程。如果有多个线程都调用wait方法，那么具体唤醒哪个线程是随机的。

被唤醒后不能立刻从wait方法返回并继续执行，它必须获取共享对象的监视器锁之后才可以返回。所以说唤醒它的线程释放了共享变量的监视器锁之后，被唤醒的线程也不一定会获取到共享对象的监视器锁，该线程必须和其它线程一起竞争这个锁，只有竞争到共享变量的监视器锁之后才可以继续执行。

调用该方法之前，该线程必须获取到共享对象的监视器锁，这个要求和wait()方法是一致的，否则会抛出InterruptedException异常。

notifyAll()

一个线程调用共享对象的notifyAll()方法之后，会唤醒所有由于调用该共享对象wait系列方法被阻塞的所有线程。

public class NotifyTest {
	private static volatile Object resourceA = new Object();
	
	public static void main(String[] args) throws InterruptedException {
		Thread threadA = new Thread(new Runnable() {
			
			@Override
			public void run() {
				synchronized (resourceA) {
					System.out.println("threadA get resourceA lock");
					try {
						System.out.println("threadA begin wait");
						resourceA.wait();
						System.out.println("threadA end wait");
					}
					catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		});
		
		Thread threadB = new Thread(new Runnable() {
			
			@Override
			public void run() {
				synchronized (resourceA) {
					System.out.println("threadB get resourceA lock");
					try {
						System.out.println("threadB begin wait");
						resourceA.wait();
						System.out.println("threadB end wait");
					}
					catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		});
		
		Thread threadC = new Thread(new Runnable() {
			
			@Override
			public void run() {
				synchronized (resourceA) {
					System.out.println("threadC begin notify");
					resourceA.notify();
				}
			}
		});
		
		//启动线程
		threadA.start();
		threadB.start();
		Thread.sleep(1000); //等待线程A和B都执行到wait方法
		threadC.start();
		
		//等待线程结束
		threadA.join();
		threadB.join();
		threadC.join();
		
		System.out.println("main over");
	}
}

输出：

threadB get resourceA lock
threadB begin wait
threadA get resourceA lock
threadA begin wait
threadC begin notify
threadB end wait

最终只有一个线程被唤醒，如果将resourceA.notify();修改为resourceA.notifyAll();

输出：

threadB get resourceA lock
threadB begin wait
threadA get resourceA lock
threadA begin wait
threadC begin notify
threadA end wait
threadB end wait
main over

从结果还可以理解下，线程A和B都被唤醒了，但是线程A先竞争到了resourceA的监视器锁，所以先执行完毕了，释放了监视器锁之后，线程B也拿到了这个Monitor,然后紧接着执行完毕，最终主线程执行完毕。

关于join方法我们后续再讨论。