生产者消费者模型1

1 wait()方法

1 wait（）方法是Object中的方法，不是Thread中的
2 wait（）方法必须在同步代码块，或者同步方法中被调用，也就是说必须持有锁，否则会报异常
3 wait（）方法调用之后， 当前线程会等待，进入锁对象的等待池中，直到被唤醒或者中断被调用后，会从等待池进入锁池

2 notify()方法

1 notify（）方法是Object中的方法，不是Thread中的
2 notify（）方法必须在同步代码块，或者同步方法中被调用，也就是说必须持有锁，否则会报异常
3 notify() 方法会从锁对象的等待池中将一个线程放到锁池中，如果获得锁，该线程就会从wait（）方法被调用出重新开始执行

3 锁池和等待池

锁池： 如果线程A持有锁对象，其他线程竞争同一个锁的时候失败，就会进入到锁对象的锁池中。 锁池中，装的是那些无法持有锁的线程，一个锁池对应一个锁对象

等待池：调用wait（）方法的线程会进入到锁对象 的等待池中，一个锁池对应一个锁对象

4 代码

package com.lidongwei.mythread.test;


public class TestNotify implements Runnable{

	private final Object object = new Object();
	private  boolean flag = true;

	public void setFlag(boolean flag) {
		this.flag = flag;
	}
	public void testwait() {
		synchronized (object) {
			try {
				System.out.println("线程开始：");
				Thread.sleep(1000);
				System.out.println("线程wait：");
				object.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("线程结束");
		}
	}
	public void testnotify() {
		System.out.println("testnotify start");
		synchronized (object) {
			System.out.println("testnotify notify");
			object.notify();
		}
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
    	System.out.println("flag is");
    	System.out.println(flag);
		if(flag)
		{
			testwait();
		}
		else {
			testnotify();
		}
	}
	
	public static void main(String[] args) {
		TestNotify testNotify = new TestNotify();
		Thread thread1 = new Thread(testNotify);
		
		//停止两秒，之后等待唤醒
		thread1.start();
		//等待两秒，唤醒
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		testNotify.setFlag(false);
		Thread thread2 = new Thread(testNotify);
		thread2.start();
	}
	
}

执行结果