多线程之三 线程通信

1.传统的线程通信:wait和notify/notifyall

可以借助于Object类提供的wait()、notify()、notifyAll()三个方法，这三个方法属于Object类。但这三个方法必须由同步监视器对象来调用，这可分为两种情况
①对于用synchronized修饰的同步方法，因为该类的默认实例(this)就是同步监视器，所以可以在同步方法中直接调用这三个方法。
②对于用synchronized修饰的同步代码块，同步监视器是synchronized后括号里的对象，所以必须使用该对象调用这三个方法。

注意：notify()方法只能随机唤醒一个线程。如果要唤醒所有线程，请使用notifyAll()。

以下面demo为例，来说明其用法。

public class WaitAndNotifyDemo {
    // 锁
    static Object lock = new Object();
    
    private static class T1 implements Runnable {
        
        @Override
        public void run() {
            synchronized (lock) {
                System.out.println("T1开始");
                
                try {
                    System.out.println("T1开始等待");
                    lock.wait(5000);//wait,释放锁
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }   
                
                System.out.println("T1结束");               
            }
        }
    }

    static private class T2 implements Runnable {

        @Override
        public void run() {           
            synchronized (lock) {
                System.out.println("T2开始通知");
                lock.notify();//通知
                
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                
                System.out.println("T2结束");
            }           
        }
    }

    public static void main(String[] args) {
        Thread th1 = new Thread(new T1());
        Thread th2 = new Thread(new T2());
        th1.start();
        th2.start();
    }
}

2.使用Condition控制线程通信

如果程序不用synchronized关键字来进行同步，而是用Lock对象来保证同步，则系统中不存在隐式的同步监视器，也就不能使用wait()、notify()、notifyAll()方法进行线程通信了。
使用Lock对象的方式，Java提供了一个Condition类来保持协调，使用Condition可以让那些已经得到Lock对象却无法继续执行的线程释放Lock对象，Condition对象也可以唤醒其他处于等待的线程。
Condition将同步监视器方法wait()、notify()、notifyAll()分解成截然不同的对象，以便通过将这些对象与Lock对象组合使用，为每个对象提供多个等待集(wait-set)。在这种情况下，Lock替代了同步方法和同步代码块，Condition替代了同步监视器的功能。
Condition实例被绑定在一个Lock对象上。要获得特定Lock实例的Condition实例，调用Lock对象的newCondition()方法获得即可。Condition类提供了以下三个方法：
await():
signal():

signalAll():

下面则将上面的demo改为重入锁实现，并使用Condition来控制线程通信

public class ConditionDemo {
    // 锁
    private static ReentrantLock lock = new ReentrantLock();   
    private static Condition condition = lock.newCondition();

    private static class T3 implements Runnable {

        @Override
        public void run() {
            // 加锁
            lock.lock();
            System.out.println("T3开始");
            try {
                System.out.println("T3开始等待");
                condition.await(5, TimeUnit.SECONDS);// 等待5秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("T3结束");
            // 释放锁
            lock.unlock();
        }
    }

    private static class T4 implements Runnable {

        @Override
        public void run() {
            //加锁
            lock.lock();
            System.out.println("T4开始");

            System.out.println("T4开始等待");
            condition.signal();//通知

            System.out.println("T4结束");
            //释放锁
            lock.unlock();
        }
    }
    
    public static void main(String[] args) {
        Thread th3 = new Thread(new T3());
        Thread th4 = new Thread(new T4());
        th3.start();
        th4.start();
    }
}

3.使用阻塞队列(BlockingQueue)控制线程通信

Java5提供了一个BlockingQueue接口，虽然BlockingQueue也是Queue的子接口，但它的主要用途不是作为容器，而是作为线程同步的工具。
BlockingQueue具有一个特征：当生产者线程试图向BlockingQueue中放入元素时，如果该队列已满，则线程被阻塞。而取元素时，如果该队列已空，则该线程被阻塞。
程序的两个线程通过交替向BlockingQueue中放入元素、取出元素，即可很好地控制线程的通信。

4.使用管道流进行线程通信(少用)

实际上由于两个线程属于同一个进程，它们可以非常方便地共享数据，因此很少需要使用管道流进行通信。