Java线程wait-notify+sleep+synchronized

1. sleep-wait-yield区别

sleep是Thread类中的一个静态方法，其定义如下,
  public static void sleep(long millis)throws InterruptedException
在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响,如果指定睡眠的时间到达，则从阻塞状态转变成就绪状态，等待运行。

  yield只是使当前线程重新回到可执行状态，让其它同一优先级的线程先运行，所以执行yield()的线程有可能进入到可执行状态后马上又被执行。

  wait是Object类中定义的方法，与notify/notifyAll()在一起成对使用，提供线程间的等待-通知机制。
   wait是Object类的方法,其定义如下,
   public final void wait()throws InterruptedException//相当于wait(0)
   public final void wait(long timeout)throws InterruptedException
   在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。
  
   调用wait()/notify()时，都必须首先获得相关的锁.而wait()被调用后，会释放之前进行同步块所获取到的锁。
    synchronized(obj){
       //wait(), notify(), notifyAll()
    }


2. wait-notify等待通知机制
   wait/notify提供了一种通知机制,wait/notify关键字适用于一个线程通知另一个线程所需的条件状态已就绪，最常用于线程在循环中休眠直到获取特定条件的场景。

 

  synchronized(lock){
	//flag初始为false,是为了避免在执行wait()以前，notify()就已经执行了。		
	while(!flag){
		try {
			lock.wait();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
        //具体的业务逻辑在这里
        obj.doSomething();
    }

    synchronized(lock){
	flag = true;
	lock.notify();
    }

    为什么要使用flag?
    因为完全有可能notify()在wait()前被调用，这时wait()就会无限的等待下去，而没有任何通知。而加上flag，无论notify(),wait()谁先执行，都不会对最终结果造成任何的影响。假如,notify()先调用，那么wait所在的while-block将不会被执行，直接执行业务逻辑相关代码；如果wait()先执行，所在线程将阻塞，而此时notify()给出通知，wait()线程重新执行，并退出while-block，执行业务逻辑代码。

   测试代码:

两个线程共享的locker和标识flag放在一个全局变量类中

  class GlobalVar{
	
	public final static Object locker = new Object();
	public static boolean flag = false;
   }

  Waiter类

  class Waiter extends Thread{
	
	public void run(){
	
		while(true){	
			
			synchronized(GlobalVar.locker){
				
				while(!GlobalVar.flag){
				
					try {
						GlobalVar.locker.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				
				GlobalVar.flag = false;
			}//synchronized end
			
			//do something here
			System.out.println("Waiter:完成一个新分配的任务");
		}
	}
   }

Noticer类

class Noticer extends Thread{
	
	public void run(){
	
		synchronized(GlobalVar.locker){
			GlobalVar.flag = true;
			GlobalVar.locker.notify();
			System.out.println("Noticer:分配一个新任务通知");
		}
	}
}

Main函数所在类

public class Test2 {

	public static void main(String[] args) {
		
		Noticer n = new Noticer();
		Waiter w = new Waiter();

		n.start();
		w.start();
		
	}
}

测试输出:
Noticer:分配一个新任务通知
Waiter:完成一个新分配的任务

使用wait-notify需要注意:

(1).调用 notify是随机的唤醒某一thread.而notifyAll则是唤醒所有等待的线程, 但只有一个线程可以在唤醒后lock object monitor,所以, notifyAll操作也是有利弊的.

(2). wait、notify、notifyAll必须在synchronized修饰的代码块中执行，否则会在运行的时候抛出IllegalMonitorStateException异常

(3).在循环语句wait的时候一定要设定循环的条件--这样能够避免wait开始之前，线程所需的条件已经被其他线程提供了却依然开始此线程wait导致的时间消耗。同时，这种办法还能够保证你的代码不被虚假的信息唤醒。

(4).总是要保证在调用notify和notifyAll之前，能够提供符合线程退出等待的条件。否则会出现即使线程接收到通知信息，却不能退出循环等待的情况。


3. join()方法
  join方法是使当前线程阻塞,直到所引用的线程结束才激活.
  public final void join()throws InterruptedException


4. synchronized关键字
   synchronized有四种使用方式:
   
   synchronized method(){}
　 synchronized (obj)
　 static synchronized method(){}
　 synchronized(classname.class)

   前面两个使用的锁是对象monitor，后面两者使用的是类monitor，都可以实现互斥访问。
一个对象只有一个对象monitor，一个类也只有一个类monitor。静态方法使用类monitor进行同步，而普通方法则使用对象monitor进行同步。