Java多线程详解（六）------ 线程间通信（等待通知及管道流）

1 等待/通知机制

A的执行需要依赖于B的一些条件，A进入等待状态wait，B持续执行，当达到A期望的条件时，通知A继续执行任务notify。这就是线程间的通信。

1.1 不使用wait/notify机制实现线程间通信

使用while语句轮询机制来检测某一个条件，这样做有缺陷。如果轮询的时间间隔很小while(true)，非常浪费CPU资源；如果轮询的时间间隔很大，有可能取不到想要的结果。

1.2 等待wait/通知notify机制的实现

方法wait()的作用是使当前执行代码的线程进行等待，该方法用来将当前线程置入预执行队列中，并且在wait()所在的代码行处停止执行，直到接到通知或被中断为止。在调用wait()之前，线程必须获得该对象的对象级别锁，即只能在同步方法或同步块中调用wait()方法。调用wait()方法后，当前线程释放锁。

方法notify()也要在同步方法或同步块中调用，如果没有获得锁的情况下调用wait()或notify()，会抛出IllegalMonitorStateException。该方法用来通知那些等待该对象的对象锁的其它线程，若有多个线程等待，则由线程规划器随机挑选出其中一个呈wait状态的线程，对其发出通知notify，并使它获取该对象的对象锁。

在执行完notify()方法后，当前线程不会马上释放该对象锁，呈wait()状态的线程也并不能马上获取该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出synchronized代码块后，当前线程才会释放锁。

wait使线程停止运行，而notify使停止的线程继续运行

• yield()方法的作用是放弃当前的CPU资源，将它让给其它的任务去占用CPU执行时间。但放弃的时间不确定，有可能刚放弃，马上又获得CPU时间片。
• 新创建一个新的线程对象后，再调用它的start()方法，系统会为此线程分配CPU资源，使其处于Runnable（可运行）状态，这是一个准备运行的阶段。如果线程抢占到CPU资源，此线程就处于Running（运行）状态。

Blocked是阻塞的意思，出现阻塞的情况大体分为如下5中：

1. 线程调用了sleep()方法，主动放弃占用的处理器资源；
2. 线程调用了阻塞式IO方法，在该方法返回前，该线程被阻塞；
3. 线程试图获得一个同步监视器，但该同步监视器正被其他线程所持有；
4. 线程等待某个通知；
5. 程序调用了suspend方法将该线程挂起。此方法容易导致死锁，尽量避免使用该方法。

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

1.3 方法wait()锁释放与notify()锁不释放

方法wait()被执行后，锁被自动释放，但执行完notify()方法，锁却不自动释放，必须执行完notify()方法所在的同步synchronized代码块后才释放锁。notify()一次只会随机通知一个线程进行唤醒，使用notifyAll()方法唤醒所有线程。sleep()方法不释放锁。

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

1.4 方法wait(long)的使用

带一个参数的wait(long)方法的功能时等待某一时间内是否有线程对锁进行唤醒，如果超过这个时间则自动唤醒，也可以提前进行唤醒。

通知过早：notify先执行，然后再触发wait，则会导致wait所在的线程不会收到通知，其后续代码就不会执行了。

2 生产者/消费者模式实现

public class ValueObject {
    public static String value = "";
}
public class P {
    private String lock;

    public P() {
    }

    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.printStackTrace();
        }
    }
}
public class C {
    private String lock;
    public C() {
    }
    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() {
    }
    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() {
    }
    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 pThread = new ThreadP(p);
        ThreadC cThread = new ThreadC(c);
        pThread.start();
        cThread.start();
    }
}

生产者执行代码发现内容不为空，则等待，释放锁，线程对象while(true)一直判断；消费者拿到锁，消费掉内容。

3 通过管道进行线程间通信

管道流（pipeStream）是一种特殊的流，用于在不同线程间直接传送数据。一个线程发送数据到输出管道，另一个线程从输入管道中读数据。JDK提供了4个类来使线程间可以进行通信：

• PipedInputStream和PipedOutputStream
• PipedReader和PipedWriter

3.1 字节流

字节流写的是字节数据。

public class ReadData {
    public void readMethod(PipedInputStream input) {
        try {
            System.out.println("read :");
            byte[] byteArray = new byte[20];
            // 阻塞式IO
            int readLength = input.read(byteArray);
            while (readLength != -1) {
                String newData = new String(byteArray, 0, readLength);
                System.out.print(newData);
                readLength = input.read(byteArray);
            }
            System.out.println();
            input.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
public class WriteData {
    public void writeMethod(PipedOutputStream out) {
        try {
            System.out.println("write :");
            for (int i = 0; i < 300; i++) {
                String outData = "" + (i + 1);
                out.write(outData.getBytes());
                System.out.print(outData);
            }
            System.out.println();
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
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 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 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);
            threadRead.start();

            Thread.sleep(2000);

            ThreadWrite threadWrite = new ThreadWrite(writeData, outputStream);
            threadWrite.start();

        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

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

在上面的代码中，首先是读取线程new ThreadRead(inputStream)启动，由于此刻没有数据被写入，所以线程阻塞在int readLength = input.read(byteArray);代码处，直到有数据被写入，才继续向下运行。

3.2 字符流

字符流写的是字符及字符串。

PipedReader和PipedWriter，使用方式上通字节流。