java线程之间的通信（wait/notify）

    在多线程开发过程中，每一个线程拥有自己的栈空间，就如同运行脚本程序一样，一行一行的运行直到最后结束。但是在线程运行过程中只是孤立的运行显得太单调，如果多线程之间可以相互协调工作才显得跟丰富。

    线程之间怎么通信呢？本文主要讲述通过Object类提供的wait和notify两个函数，并结合synchronized关键字来实现线程之间的通信，文章最后通过一道面试题来进行总结。

    在Object类中提供了两个native修饰的方法（如下图），如果调用wait方法使得当前线程进入WAITING状态，并且线程释放获得的锁直到其他线程调用notify或者notifyAll方法，WAITING状态的线程才可能被唤醒。并且只有当调用notfiy的线程释放锁，之前的WAITING线程才能够从wait方法中返回。

public final native void wait(long timeout) throws InterruptedException;

public final native void notify();

    下面来看看使用wait和notify需要注意的地方：

        1、调用wait、notify或者notifyAll方法需要先对调用对象进行加锁（synchronized或者Lock）；

        2、调用wait方法后，线程从RUNNING状态转变成WAITING状态，并将当前线程放入对象等待队列中；

        3、notify或者notifyAll方法被调用后，等待线程不会立即从wait方法中返回，需要调用notify或者notifyAll的线程释放锁后，等待线程才可能从wait方法返回；

        4、notify方法将对象等待队列中一个等待线程移出到同步队列中，而notifyAll线程将对象等待队列中的等待线程全部移出到同步队列中，并且这些线程的状态将由WAITING状态变成BLOCKED状态；

        5、从wait方法返回前，线程已经获得了调用对象的锁。

    总结，这里使用一个多线程笔试来总结，题目：请使用多线程一次打印,ABABABAB....，每一个字母打印前停留1秒。    

public class PrintAB {

    private static Object lock = new Object();
    private static volatile boolean bl = true;
    public static void main(String[] args) throws InterruptedException {
        Thread a = new PrintA();
        Thread b = new PrintB();
        a.start();
        TimeUnit.SECONDS.sleep(1);
        b.start();
    }

    static class PrintA extends Thread {

        @Override
        public void run() {
            while (true) {
                synchronized (lock) {
                    if (bl) {
                        System.out.print("A");
                        bl = false;
                    }
                    try {
                        try {
                            TimeUnit.MILLISECONDS.sleep(990);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                try {
                    TimeUnit.MILLISECONDS.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    static class PrintB extends Thread {
        @Override
        public void run() {
            while (true) {
                synchronized (lock) {
                    if (!bl) {
                        System.out.print("B");
                        bl = true;
                    }
                    try {
                        TimeUnit.MILLISECONDS.sleep(990);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    lock.notifyAll();
                }
                try {
                    TimeUnit.MILLISECONDS.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

    实例中使用两个线程，其中一个线程用于打印A，另一线程打印B，两个线程使用同一个锁lock，和共享变量bl（使用volatile关键字，实现多线程内存可见性），使用notfiy和wait实现线程直接的通信。

    在第一个线程启动之后sleep了1秒，是为了保证第一线程先拿到lock锁，保障第一次总是打印A。在线程中synchronized同步块里面sleep了990毫秒，然后在synchronized同步块外面sleep了10毫秒，这里的目的是保障当一个线程释放锁后能够被另一个线程拿到，不至于同一个线程联系两次拿到锁。因为在synchronized同步块中sleep时，线程是不会释放锁这样保障每打印一个字符直接停隔1秒，synchronized同步块外面sleep时，线程是没有获得锁的，此时另一个线程就会去获得锁。