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中的值进行更改，那么子线程取到的值还是旧值。