JAVA多线程之Object的（wait（）、notify（））

如果需要调用一个对象的wait()方法，当前线程必须持有这个对象的锁，因此调用wait()方法必须在同步块或者同步方法中进行（synchronized块或者synchronized方法）。

　　调用某个对象的wait()方法，相当于让当前线程交出此对象的锁，然后进入等待状态，等待后续再次获得此对象的锁（Thread类中的sleep方法使当前线程暂停执行一段时间，从而让其他线程有机会继续执行，但它并不释放对象锁）；

　　notify()方法能够唤醒一个正在等待该对象的monitor的线程，当有多个线程都在等待该对象的monitor的话，则只能唤醒其中一个线程，具体唤醒哪个线程则不得而知。具体参照下面生产者与消费者的实例：

  缓存池：

package nc.com.thread.Condition.example;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 
* @ClassName: CacheCondition 
* @Description: 生产者与消费者共同持有的蛋糕存取池
* @author A18ccms a18ccms_gmail_com 
* @date 2016-3-20 下午03:29:40 
*
 */
public class CacheCondition {
    private int limit=100;
	private Lock lock = new ReentrantLock();
	private Condition isEmpty=lock.newCondition();
	private Condition isFull= lock.newCondition();
	private List<Cake> cache=new ArrayList<Cake>(limit);
	private CacheCondition(){
		
	}
	private static class SingleHoder{
		private static CacheCondition instance = new CacheCondition();
	}
	
  public static CacheCondition getInstance(){
	  return SingleHoder.instance;
  }
	
  public void put(Cake cake){
	  try {
		  lock.lockInterruptibly();
		  while(cache.size()>=limit){
			  System.out.println(""+Thread.currentThread().getName()+"等待放入蛋糕，缓存池已满");
			  isFull.await();
	    	  System.out.println(""+Thread.currentThread().getName()+"被唤醒,可以继续生产");
		  }
		  cache.add(cake);
		  isEmpty.signal();
		  System.out.println(""+Thread.currentThread().getName()+"放入蛋糕："+cake.toString()+"，池中总共蛋糕"+cache.size());
	} catch (Exception e) {
		e.printStackTrace();
	}finally{
		lock.unlock();
	}
  }
  
  public Cake getCake(){
		Cake cake=null;
		try {
			 lock.lockInterruptibly();
			 while(cache.size()<=0){
				 System.out.println(""+Thread.currentThread().getName()+"等待获取蛋糕，缓存池已空");
				 isEmpty.await(); 
				 System.out.println(""+Thread.currentThread().getName()+"被唤醒，缓存池已有蛋糕");
			 }
			 cake=cache.remove(0);
			 isFull.signal();
			 System.out.println(""+Thread.currentThread().getName()+"获得蛋糕："+cake.toString()+"，池中剩下总共蛋糕"+cache.size());
		} catch (Exception e) {
        e.printStackTrace();
		}finally{
			lock.unlock();
		}
		return cake;
	}

}
           

蛋糕类：

package nc.com.thread.Condition.example;

/**
 * 
* @ClassName: Cake 
* @Description: 蛋糕类 
* @author A18ccms a18ccms_gmail_com 
* @date 2016-3-20 下午03:31:02 
*
 */
public class Cake {

	private String color;
	private int price;

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}

	public int getPrice() {
		return price;
	}

	public void setPrice(int price) {
		this.price = price;
	}

	@Override
	public String toString() {
		return "Cake [color=" + color + ", price=" + price + "]";
	}

}
           

生产者：

package nc.com.thread.Condition.example;
/**
 * 
* @ClassName: Productor 
* @Description: 蛋糕生产者
* @author A18ccms a18ccms_gmail_com 
* @date 2016-3-20 下午03:32:05 
*
 */
public class Productor  implements Runnable{

	@Override
	public void run() {
		try {
			while(true){
				Cake  cake =  new Cake();
				cake.setPrice((int) Thread.currentThread().getId());
				cake.setColor(""+Thread.currentThread().getName()+"放入red");
				CacheCondition.getInstance().put(cake);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
}
           

消费者：

package nc.com.thread.Condition.example;

/**
 * 
* @ClassName: Customer 
* @Description: 消费者 
* @author A18ccms a18ccms_gmail_com 
* @date 2016-3-20 下午03:32:54 
*
 */
public class Customer  implements Runnable{

	@Override
	public void run() {
		try {
			while(true){
				Thread.sleep(2000);
				Cake  cake=CacheCondition.getInstance().getCake();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
}
           

测试类：

package nc.com.thread.Condition.example;


public class ThreeConditionCommunication {
	public static void main(String[] args) {
		
		 for(int num =0;num<10;num++){
			 Customer c = new Customer();
			 new Thread(c,"消费者"+num).start();
			 
		 }
		 try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		 for(int num =0;num<2;num++){
			 Productor p = new Productor();
			 new Thread(p,"生产者"+num).start();
		 }
	}
}