线程间通信

　　如果一个多线程程序中每个线程处理的资源没有交集，没有依赖关系那么这是一个完美的处理状态。你不用去考虑临界区域（critical section），不用担心存在所谓的条件竞争（race condition），当然也不用去单行执行顺序，当然这种状态只是完美情况下，事实往往没有这么完美。

　　当多个线程进入临界区域对临界资源进行修改或者读取的时候，往往需要确定线程的执行顺序，以保证共享资源的可见性和相关操作的原子性。这就涉及到线程间的通信了，即

如果线程A正好进入临界区，他可能对临界资源进行修改或者读取，这时候他就要通知随时想要进入临界区域的线程B：“你丫的等一下，现在只准我来访问”。我们称这时候线程A拥有了访问临界区的锁。我们可以将锁看做是一个通行证，拥有锁的可以在临界区畅通无阻，而没有锁的则需要在门外等着锁。我们将多个线程的执行过程看做是接力赛，线程A拿着通行证玩遍临界区之后，还需要将通行证交给下一个想要进入临界区的线程。当然具体交给谁，你如果纯粹交给操作系统来决断，这就可能产生各种意想不到的后果。极有可能的是刚刚明明决定传给线程B的，但是就因为线程A多看了线程C一眼，从此就对上了眼，从而把通行证交给了C..... 

　　扯得有点远，不过从上一段我们可以看出线程间最简单粗暴的通信可以通过加锁解锁来实现。最简单的方式就是synchronized同步块。如下程序所示：

private int count;

public synchronized int increment() {
    return count++;
}

     这种说是通信方式，其实说是独占方式来的更准确些，其实使用synchronized同步块之后，能够访问进入临界区域的只有一个线程。

    我们考虑另外一种情况，通过信号来实现线程间通信。就像古装剧里面，在进攻之前一般会发一些信号，一些等待的线程只有收到信号改变的时候才会运行，比如下面代码的这种情况：

public class SimpleSignal {
    public static void main(String[] args) {
        Signal signal = new Signal();
        SignalThread t1 = new SignalThread(signal);
        SignalThread t2 = new SignalThread(signal);
        t1.start();
        t2.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        signal.start();
    }
}

class Signal {
    private boolean startAction = false;

    public synchronized void start() {
        this.startAction = true;
    }

    public synchronized boolean isStarted() {
        return this.startAction;
    }
}

class SignalThread extends Thread {
    private final Signal signal;

    public SignalThread(Signal signal) {
        this.signal = signal;
    }

    @Override
    public void run() {
        while (!signal.isStarted()) {
            // 什么也不做，等待可以开始行动
        }

        System.out.println("Thread:" + Thread.currentThread()
                + " Go Go Go!Fighting!");
    }

}

 　上面的代码可以看出在主线程调用signal.start()之前，线程t1.t2都不会继续执行，而是阻塞在while循环中等待主线程给出的进攻信号。这中通信实现方式叫做忙等待（busy wait），线程t1和线程t2，一直在while循环判断条件是否符合，这时候会一直占用CPU处理时间，从CPU利用率上来说不是那么好。

　　那么又没有改进方法呢，当然是有的，不必像前面的一样傻傻的望着天空看是否有信号灯，假如事情顺利的话派探子前来告知。在等待的过程中完全可以放弃对CPU的占用，让CPU去处理其他更加紧急的事情，从而提高CPU的利用率。当有探子来报的时候，CPU则唤醒原来的线程继续执行。升级版本1.0代码如下：

public class SignalUpV1Test {
    public static void main(String[] args) throws InterruptedException {
        SignalUpV1 signal = new SignalUpV1();
        SignalThreadUpV1 t1 = new SignalThreadUpV1(signal);
        SignalThreadUpV1 t2 = new SignalThreadUpV1(signal);
        t1.start();
        t2.start();
        Thread.sleep(1000);
        System.out
                .println("Now the Main Thread call doNotify of the signal Object!");
        signal.doNotify();
    }
}

class SignalThreadUpV1 extends Thread {
    private final SignalUpV1 signal;

    public SignalThreadUpV1(SignalUpV1 signal) {
        this.signal = signal;
    }

    @Override
    public void run() {
        try {
            // 这里线程等待，给CPU去执行其他事情，然后等着被唤醒
            signal.doWait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread" + Thread.currentThread() + " Running");
    }

}

class SignalUpV1 {
    private final Object monitorObject = new Object();

    public void doWait() throws InterruptedException {
        // 注意在哪个对象上调用wait或者notify则必须对哪个对象加锁，而不能对其他对象加锁，否则会报IllegalMonitorStatus异常
        synchronized (monitorObject) {
            monitorObject.wait();
        }
    }

    public void doNotify() {
        synchronized (monitorObject) {
            monitorObject.notify();
        }
    }
}

输出为：
Now the Main Thread call doNotify of the signal Object!
ThreadThread[Thread-0,5,main] Running

　　可以看到线程t1或者t2必须等待主线调用监视对象的doNotify方法才会继续往下执行，否则会一直等待，当然从输出结果中也可以看出，doNotify一次只能唤醒一个线程，程序执行完后JVM还是没法退出因为有一个线程还是处于等待状态（要想都唤醒请使用notifyAll而不是notify）。同时还需要注意的一点是Object对象的wait和notify方法，必须在拥有该对象的锁之后才能调用，否则会报IllegalMonitorStatus异常。

　　这种通信方式还是会存在信号丢失的问题（Signal Missing）。即加入调用监视对象的doNotify方法在doWait方法之前，那么前面等待的线程可能永远无法被唤醒，解决这种问题的办法就是加一个标志位，来存储线程是否已经被唤醒过，在线程调用wait方法之前，判断线程是否已经被唤醒，如果没有则调用wait等待唤醒，如果有则不调用wait直接执行。升级版本2.0如下：

public class SignalUpV2Test {
    public static void main(String[] args) {
        SignalUpV2 signal = new SignalUpV2();
        SignalThreadUpV2 t1 = new SignalThreadUpV2(signal);
        SignalThreadUpV2 t2 = new SignalThreadUpV2(signal);

        // 假设先调用监视对象的doNotify方法
        signal.doNotify();
        t1.start();
        t2.start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out
                .println("Now the main thread call the signal's doNotify method");
        signal.doNotify();
    }
}

class SignalThreadUpV2 extends Thread {
    private final SignalUpV2 signal;

    public SignalThreadUpV2(SignalUpV2 signal) {
        this.signal = signal;
    }

    @Override
    public void run() {
        try {
            signal.doWait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread:" + Thread.currentThread() + " running!");
    }
}

class SignalUpV2 {
    /**
     * 是否已经被唤醒的标志位。防止先调用doNotify导致的信号丢失问题从而使线程一直等待被唤醒
     */
    private boolean isNotified = false;

    private final Object monitorObject = new Object();

    public void doWait() throws InterruptedException {
        synchronized (monitorObject) {
            if (!isNotified) {
                monitorObject.wait();
            }
            this.isNotified = false;
        }
    }

    public void doNotify() {
        synchronized (monitorObject) {
            this.isNotified = true;
            monitorObject.notify();
        }
    }
}

输出结果：
Thread:Thread[Thread-1,5,main] running!
Now the main thread call the signal's doNotify method
Thread:Thread[Thread-0,5,main] running!

　　这个通信版本看起来天衣无缝，事实上在大多数情况下是。但是还有一个不幸的消息，就是操作系统可能无法抑制躁动的心灵。他可能会存在虚假唤醒的情况（Spurious Wakeups）。即存于等待状态的线程可能无缘无故的被唤醒，从而离开wait方法继续执行。解决这种问题的办法很简单，使用while循环判断代替if判断，这样即使线程被虚假唤醒还是会去校验唤醒状态标志位是否为true，如果标志位还是false，会继续进入wait状态。从而完美解决了这个问题。实际上这种使用while检测唤醒标识位的方式是通过自旋锁（Spin Lock）来实现的。自旋锁在处理的过程中不会进行备份然后完全离开线程运行状态，而是仍然会占用CPU的处理时间，但是不会有线程切换的开销。升级版本3.0的代码这里不给出了，只需把if改成while即可。