生产者与消费者

1，wait与notify:

wait和notify是java中任何一个对象都有的方法。

某对象调用wait()方法：在该对象上活动的线程进入等待状态，直到被唤醒。

某对象调用notify()方法，在该对象上的线程被唤醒。而notifyAll是唤醒所有等待的线程。

Notations: wait()方法会让当前对象进入等待状态，并释放对象锁。notify()方法只是通知，不进行释放。wait()方法都要在synchronlized的代码块里面调用。

2,生产者与消费者：

该模式是为了解决专门的需求。

一个线程负责生产，一个负责消费，最终需要达到生产消费相平衡。如图所示：

实现该模式的一个简单逻辑：

 

实现代码：

public class test {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		List L=new ArrayList();
		Thread pro=new Thread(new Producer(L));
		Thread con=new Thread(new Consumer(L));
		pro.setName("生产者");con.setName("消费者");
		pro.start();con.start();
		
	}
}
//用List模拟仓库，一个就表示满了
class Producer implements Runnable{
	private List L;
	public Producer(List L) {
		this.L=L;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(true) {
			synchronized(L){
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}
				if (L.size()>0) {
					try {
						L.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					//L表示仓库，当仓库中大于0，停止生产，释放了对象锁拿给消费者
				}
				//进行生产
				Object o=new Object();
				L.add(o);
				System.out.println(Thread.currentThread().getName()+":"+o);
				L.notify();
				//唤醒消费者线程，但不会释放锁
		}
	}
}
}
class Consumer implements Runnable{
	private List L;
	public Consumer(List L) {
		this.L=L;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(true) {
			synchronized(L) {
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}
				if (L.size()==0) {
					try {
						L.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					//当L为0时，停止消费
				}
				System.out.println(Thread.currentThread().getName()+"："+L.get(0));
				L.remove(0);
				L.notify();
				//唤醒生产者
			}
		}	
	}
}