Java线程间通信

1. 等待/通知机制

  多个线程之间可以通过共同访问同一个变量来实现通信，但这种通信机制不是“等待/通知”，两个线程完全是主动式地读取一个共享变量，在花费读取时间的基础上，读到的值是不是想要的，并不能完全确定。

1.1 wait()方法

  方法wait()的作用是使当前执行代码的线程进行等待，wait()方法是Object类的方法，该方法用来将当前线程置入“预执行队列”中，并且在wait()所在的代码行处停止执行，直到接到通知或被中断为止。
  在调用wait()之前，线程必须获得该对象的对象级别锁，即只能在同步方法或同步块中调用wait()方法。在执行wait()方法后，当前线程释放锁。在从wait()返回前，线程与其他线程竞争重新获得锁。如果调用wait()时没有持有适当的锁，则抛出IllegalMonitorStateException，它是RuntimeException的一个子类，因此，不需要try-catch语句进行捕捉异常。

1.2 notify()方法

  方法notify()也要在同步方法或同步块中调用，即在调用前，线程也必须获得该对象的对象级别锁。如果调用notify()时没有持有适当的锁，也会抛出IllegalMonitorStateException。该方法用来通知那些可能等待该对象的对象锁的其他线程，如果有多个线程等待，则由线程规划器随机挑选出其中一个呈wait状态的线程，对其发出通知notify，并使它等待获取该对象的对象锁。需要说明的是，在执行notify()方法后，当前线程不会马上释放该对象锁，呈wait状态的线程也并不能马上获取该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出synchronized代码块后，当前线程才会释放锁，而呈wait状态所在的线程才可以获取该对象锁。当第一个获得了该对象锁的wait线程运行完毕以后，它会释放掉该对象锁，此时如果该对象没有再次使用notify语句，则即便该对象已经空闲，其他wait状态等待的线程由于没有得到该对象的通知，还会继续阻塞在wait状态，直到这个对象发出一个notify或notifyAll。
  如果发出notify操作时没有处于阻塞状态中的线程，那么该命令会被忽略。

1.3 就绪队列和阻塞队列

  每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列。就绪队列存储了将要获得锁的线程，阻塞队列存储了被阻塞的线程。一个线程被唤醒后，才会进入就绪队列，等待CPU的调度；反之，一个线程被wait后，就会进入阻塞队列，等待下一次被唤醒。

1.4 锁释放的几种情况

• 执行完同步代码块就会释放对象的锁。
• 在执行同步代码块的过程中，遇到异常而导致线程终止，锁也会被释放。
• 在执行同步代码块的过程中，执行了锁所属对象的wait()方法，这个线程会释放对象锁，而此线程对象会进入线程等待池中，等待被唤醒。

1.5 生产者/消费者模式

  等待/通知模式最经典的案例就是“生产者/消费者”模式。示例代码如下（一生成与一消费）：
值存储对象

public class ValueObject {    public static String value = "";}

生产者

public class P {    private String lock;    public P(String lock) {        this.lock = lock;    }    public void setValue() {        try {            synchronized (lock) {                if (!ValueObject.value.equals("")) {                    lock.wait();                }                String value = System.currentTimeMillis() + "_" + System.nanoTime();                System.out.println("set的值是 " + value);                ValueObject.value = value;                lock.notify();            }        } catch (InterruptedException e) {            e.pringStackTrace();        }    }}

消费者

public class C {    private String lock;    public C (String lock) {        this.lock = lock;    }    public void getValue() {        try {            synchronized (lock) {                if (ValueObject.value.equals("")) {                    lock.wait();                }                System.out.println("get的值是 " + ValueObject.value);                ValueObject.value = "";                lock.notify();            }        } catch (InterruptedException e) {            e.printStackTrace();        }    }}

生产者线程

public class ThreadP extends Thread {    private P p;    public ThreadP(P p) {        this.p = p;    }    @Override    public void run() {        while (true) {            p.setValue();        }    }}

消费者线程

public class ThreadC extends Thread {    private C c;    public ThreadC(C c) {        this.c = c;    }    @Override    public void run() {        while (true) {            c.getValue();        }    }}

运行类

public class Run {    public static void main(String[] args) {        String lock = new String("");        P p = new P(lock);        C c = new C(lock);        ThreadP threadP = new ThreadP(p);        ThreadC threadC = new ThreadC(c);        threadP.start();        threadC.start();    }}

2. 通过管道进行线程间通信

2.1 线程间通信类

  在Java的JDK中提供了4个类来使线程间可以进行通信：PipedInputStream、PipedOutputStream、PipedReader、PipedWriter。

2.2 线程间通信方法

  使用方法inputStream.connect(outputStream)或outputStream.connect(inputStream)可以使两个Stream之间产生通信链接，这样才可以将数据进行输出与输入。

2.3 示例代码

数据输出类

public class WriteData {    public void writeMethod(PipedOutputStream out) {        /**        * 通过输出流进行数据输出        */    }}

数据读取类

public class ReadData {    public void readMethod(PipedInputStream input) {        /**        * 通过输入流进行数据读取并解析        */    }}

输出线程

public class ThreadWrite extends Thread {    private WriteData write;    private PipedOutputStream out;    public ThreadWrite(WriteData write, PipedOutputStream out) {        this.write = write;        this.out = out;    }    @Override    public void run() {        write.writeMethod(out);    }}

读取线程

public class ThreadRead extends Thread {    private ReadData read;    private PipedInputStream input;    public ThreadRead(ReadData read, PipedInputStream input) {        this.read = read;        this.input = input;    }    @Override    public void run() {        read.readMethod(input);    }}

运行类

public class Run {    public static void main(String[] args) {        try {            WriteData writeData = new WriteData();            ReadData readData = new ReadData();            PipedInputStream inputStream = new PipedInputStream();            PipedOutputStream outputStream = new PipedOutputStream();            // inputStream.connect(outputStream);            outputStream.connect(inputStream);            ThreadRead threadRead = new ThreadRead(readData, inputStream);            treadRead.start();            Thread.sleep(2000);            ThreadWrite threadWrite = new ThreadWrite(writeData, outputStream);            threadWrite.start();        } catch (IOException | InterruptedException e) {            e.printStackTrace        }    }}

3. 方法join()

3.1 作用

  方法join()的作用是等待线程对象销毁，即使所属的线程对象x正常执行run()方法中的任务，而使当前线程z进行无限期（join(long millis)是有限期的）的阻塞，等待线程x销毁后再继续执行线程z后面的代码。

3.2 join(long)与sleep(long)的区别

  方法join(long)的功能在内部是使用wait(long)方法来实现的，所以join(long)方法具有释放锁的特点，而Thread.sleep(long)方法却不释放锁。

4. 类ThreadLocal

4.1 作用

  类ThreadLocal解决的是变量在不同线程间的隔离性，也就是不同线程拥有自己的值，不同线程中的值是可以放入ThreadLocal类中进行保存的。

4.2 对象创建方式

• 无默认值，用时需判断是否为null

ThreadLocal t1 = new ThreadLocal();

• 有默认值，用时无需判断是否为null，此时需继承ThreadLocal类并重写initialValue()方法

public class ThreadLocalExt extends ThreadLocal {    @Override    protected Object initialValue() {        return "default_value";    }}

ThreadLocalExt = new ThreadLocalExt();

4.3 方法调用

  ThreadLocal对象获取值通过get()方法实现，设置值通过set(Object obj)方法实现。

4.4 InheritableThreadLocal类

• 作用：使用类InheritableThreadLocal可以在子线程中取得父线程继承下来的值。
• 通过重写InheritableThreadLocal类的childValue(Object parentValue)方法，子线程可以将继承的值进行修改。
• 如果子线程在取得值的同时，主线程将InheritableThreadLocal中的值进行更改，那么子线程取到的值还是旧值。