线程通信是Java线程部分的重点，我们介绍一下常见的几种线程通信方式。

线程锁与同步

锁机制是线程通信的一种重要方式。当多个线程竞争某一个对象时，一旦某个线程获得对象就会立刻将其上锁，其他线程只能等待锁被释放才可以继续竞争。当我们需要进行多个线程间的同步时，经常利用线程锁完成。
在下面的代码中，两个线程总会有一个执行先后顺序，但后执行的线程必须等待先执行的代码运行结束才可以执行。

public class ObjectLock {    private static Object obj = new Object();    static class MyRunnableA implements Runnable {        @Override        public void run() {            synchronized (obj) {                for (int i = 1; i <= 100; ++i) System.out.println("MyRunnableA: " + i);            }        }    }    static class MyRunnableB implements Runnable {        @Override        public void run() {            synchronized (obj) {                for (int i = 1; i <= 100; ++i) System.out.println("MyRunnableB: " + i);            }        }    }    public static void main(String[] args) {        new Thread(new MyRunnableA(), "线程1").start();        new Thread(new MyRunnableB(), "线程2").start();    }}

结果显示一个线程运行结束了以后才可以运行下一个线程。

等待/通知机制

等待/通知机制同样是线程通信方式中比较重要的方法，这里的等待使用的是Object类中的wait()方法，通知使用的是Object类中的notify()或notifyAll()方法，以上三个方法都必须在synchronized中使用。notify()方法一次只能随机唤醒一个等待线程，而notifyAll()会唤醒所有的等待线程。当线程使用wait()方法时，会自动释放占有的锁资源。我们用代码来查看一下。

public class WaitAndNotify {    private static Object obj = new Object();    static class MyRunnableA implements Runnable {        @Override        public void run() {            synchronized (obj) {                for (int i = 0; i < 5; ++i) {                    System.out.println("MyRunnableA: " + i);                    obj.notify();                    try {                        obj.wait();                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }                obj.notify();            }        }    }    static class MyRunnableB implements Runnable {        @Override        public void run() {            synchronized (obj) {                for (int i = 0; i < 5; ++i) {                    System.out.println("MyRunnableB: " + i);                    obj.notify();                    try {                        obj.wait();                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }                obj.notify();            }        }    }    public static void main(String[] args) {        new Thread(new MyRunnableA(), "线程1").start();        new Thread(new MyRunnableB(), "线程2").start();    }}

上面的代码交替等待和唤醒对方从而实现交替打印的效果，结果如下。

volatile共享内存

volatile关键字保证了线程间的内存可见性，本文暂不展开讲，后面会有专门的文章讲volatile和JMM(Java内存模型)相关的内容。

public class VolatileDemo {    private static volatile boolean flag = true;    static class MyRunnableA implements Runnable {        @Override        public void run() {            System.out.println("start time: " + System.currentTimeMillis());            while (flag) ;            System.out.println("flag已被置为false");            System.out.println("end time: " + System.currentTimeMillis());        }    }    static class MyRunnableB implements Runnable {        @Override        public void run() {            try {                TimeUnit.SECONDS.sleep(1);            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println("flag即将被置为false");            flag = false;        }    }    public static void main(String[] args) {        new Thread(new MyRunnableA(), "线程1").start();        new Thread(new MyRunnableB(), "线程2").start();    }}

以上的代码线程1初始时会阻塞在while循环里，但是线程2休眠1秒后将主内存中的flag改成了false，线程1第一时间获取了主内存的变量值变化并退出循环。具体结果如下：

管道

Java提供了四个类来实现管道，分别是PipedReader、PipedWriter、PipedInputStream和PipedOutputStream。前两个是面向字符的，后两个是面向字节的。下面的代码实现了一个简单的管道通信，模拟了C/S结构的通信。

public class Pipeline {    private static PipedReader reader = new PipedReader();    private static PipedWriter writer = new PipedWriter();    static class Server implements Runnable {        @Override        public void run() {            try {                int receivedData = 0;                while ((receivedData = reader.read()) != -1) {                    System.out.print((char)receivedData);                }                System.out.println();            } catch (IOException e) {                e.printStackTrace();            } finally {                try {                    reader.close();                } catch (IOException e) {                    e.printStackTrace();                }            }        }    }    static class Client implements Runnable {        @Override        public void run() {            try {                writer.write("test");            } catch (IOException e) {                e.printStackTrace();            } finally {                try {                    writer.close();                } catch (IOException e) {                    e.printStackTrace();                }            }        }    }    public static void main(String[] args) throws InterruptedException, IOException {        writer.connect(reader);        new Thread(new Server()).start();        TimeUnit.SECONDS.sleep(1);        new Thread(new Client()).start();    }}

信号量

学过操作系统的同学们一定对信号量的概念不陌生，在Java中有一个定义信号量的工具类Semaphore。我们以一个经典的生产者-消费者模型来测试一下这种通信方式。

public class SemaphoreDemo {    static class Producer implements Runnable {        Semaphore mutex;        Semaphore empty;        Semaphore full;        public Producer(Semaphore mutex, Semaphore empty, Semaphore full) {            this.mutex = mutex;            this.empty = empty;            this.full = full;        }        @Override        public void run() {            while (true) {                try {                    System.out.println("生产一些东西");                    TimeUnit.SECONDS.sleep(1);                    empty.acquire();                    mutex.acquire();                    System.out.println("将数据放入缓冲中");                    TimeUnit.SECONDS.sleep(1);                    mutex.release();                    full.release();                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }    }    static class Consumer implements Runnable {        Semaphore mutex;        Semaphore empty;        Semaphore full;        public Consumer(Semaphore mutex, Semaphore empty, Semaphore full) {            this.mutex = mutex;            this.empty = empty;            this.full = full;        }        @Override        public void run() {            while (true) {                try {                    full.acquire();                    mutex.acquire();                    System.out.println("将数据从缓冲中取出");                    TimeUnit.SECONDS.sleep(1);                    mutex.release();                    empty.release();                    System.out.println("消费一些东西");                    TimeUnit.SECONDS.sleep(1);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }    }    public static void main(String[] args) {        Semaphore mutex = new Semaphore(1);        Semaphore empty = new Semaphore(10);        Semaphore full = new Semaphore(0);        new Thread(new Producer(mutex, empty, full)).start();        new Thread(new Consumer(mutex, empty, full)).start();    }}

上面的代码模拟了经典的生产者-消费者模型，生产者一直在生产产品，消费者一直在消费产品，我们可以得到下面的运行结果：