1 wait notify

wait/notify:

wait()使线程停止，notify使wait状态的线程继续执行。

wait()是Object类的方法，该方法用来将线程置入“预执行队列”，并在wait()方法处停止执行，直到接到通知或被中断为止。调用wait()方法必须要获得对象的锁，即只能在同步方法或同步块中调用wait()方法。调用wait()方法后，对象的锁被当前线程释放。

notify()也是在同步块或同步方法中调用，调用前必须获得对象的锁，该方法用来通知那些等待该对象的锁的其它线程。如果有多个线程等待，则挑选一个wait()状态线程，对其发出通知，如果没有线程等待，则该命令被忽略。在该notify()方法所在的synchronized块或方法执行完毕后，才使被挑选的线程获取该对象的锁。

注意：如果调用wait() 或notify() 没有持有对象的锁，会抛出IlegalMonitorStateException异常。

 package multiMethod.waitNotify;

 import java.util.LinkedList;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;

 public class MyList {
     private List<String> list = new LinkedList<String>();
     private AtomicInteger count = new AtomicInteger(0);
     private int maxSize, minSize;
     private Object lock = new Object();

     public MyList(int maxSize, int minSize) {
         this.maxSize = maxSize;
         this.minSize = minSize;
     }

     public void add() {
         synchronized (lock) {
             try {
                 if (getSize() == maxSize) {
                     lock.wait();
                 }
             } catch (Exception e) {
             }
             list.add("hello");
             System.out.println("add ...");
             count.incrementAndGet();
             lock.notify();
         }
     }

     public void take() {
         synchronized (lock) {
             try {
                 if (getSize() <= minSize) {
                     lock.wait();
                 }
             } catch (Exception e) {
                 // TODO: handle exception
             }
             list.remove(count.get()-1);
             System.out.println("take().......");
             this.count.decrementAndGet();
             lock.notify();
         }
     }

     public int getSize() {
         return count.get();
     }

     public static void main(String[] args) {
         MyList queue = new MyList(6, 3);
         Thread threadA = new Thread(new Runnable() {
             @Override
             public void run() {
                 while (true) {
                     queue.add();
                 }
             }
         });
         Thread threadB = new Thread(new Runnable() {

             @Override
             public void run() {
                 while (true) {
                     queue.take();
                 }
             }
         });

         Thread threadC = new Thread(new Runnable() {

             @Override
             public void run() {
                 while (true) {
                     System.out.println((queue.count));
                 }
             }
         });

         threadB.start();
         threadA.start();
         threadC.start();
     }
 }

每个锁对象有两个队列，一个就绪队列，一个阻塞队列。就绪队列中线程已被唤醒，等待获得cpu，阻塞队列执行了wait(),等待被唤醒。

需要注意的是：

1. notify()通知过早，线程不会被唤醒，因为wait()后于notify()执行。

2. wait等待条件发生了变化，线程也不会被唤醒。

3. 唤醒同类，线程陷入假死。如：生产者唤醒生产者，消费者唤醒消费者。