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. 唤醒同类，线程陷入假死。如：生产者唤醒生产者，消费者唤醒消费者。