java并发编程的艺术（9）多线程之间的通信

关于多线程的状态切换过程中，线程的状态会有多种的切换，在早期的jdk版本中，线程之间的切换主要是通过join，sleep，wait，notify，notifyall等系列的函数来进行状态变迁的。

线程之间的切换状态如下图所示：

线程共包括以下5种状态。

1. 新建状态(New) 

线程对象被创建后，就进入了新建状态。例如，Thread thread = new Thread()。

2. 就绪状态(Runnable)

也被称为“可执行状态”。线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程。例如，thread.start()。处于就绪状态的线程，随时可能被CPU调度执行。

3. 运行状态(Running) 

线程获取CPU权限进行执行。需要注意的是，线程只能从就绪状态进入到运行状态。

4. 阻塞状态(Blocked) 

阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
    等待阻塞 

   通过调用线程的wait()方法，让线程等待某工作的完成。
    同步阻塞 

   线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。
    其他阻塞 

    通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

5.死亡状态(Dead) 

线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

这里面我们先专门讲解下wait(), notify(), notifyAll()方法，首先结合相应的代码来说：

来一个基于wait和notify的等待通知模型代码先：

消息体：

/**
 * @author idea
 * @data 2019/3/17
 */
public class Message {

    /**
     * 消息体
     */
    private String msg;

    public Message(String str){
        this.msg=str;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String str) {
        this.msg=str;
    }

}

通知：

/**
 * @author idea
 * @data 2019/3/17
 */
public class Notifier implements Runnable {

    private Message msg;

    public Notifier(Message msg) {
        this.msg = msg;
    }

    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.println(name+" started");
        try {
            Thread.sleep(1000);
            synchronized (msg) {
                msg.setMsg(name+" waiter的名称");
                msg.notifyAll();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

}

等待者：

/**
 * @author idea
 * @data 2019/3/17
 */
public class Waiter implements Runnable {

    private Message msg;

    public Waiter(Message m) {
        this.msg = m;
    }

    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        synchronized (msg) {
            try {
                System.out.println(name + " waiting to get notified at time:" + System.currentTimeMillis());
                msg.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name + " 获取到msg的消息信息了:" + System.currentTimeMillis());
            //打印消息内容
            System.out.println(name + " processed: " + msg.getMsg());
        }
    }

}

测试类：

/**
 * @author idea
 * @data 2019/3/17
 */
public class WaitNotifyTest {

    public static void main(String[] args) {
        Message msg1 = new Message("process1 it");
        Waiter waiter = new Waiter(msg1);
        new Thread(waiter, "waiter").start();

        Waiter waiter1 = new Waiter(msg1);
        new Thread(waiter1, "waiter1").start();

        Notifier notifier = new Notifier(msg1);
        new Thread(notifier, "notifier").start();
        System.out.println("All the threads are started");
    }

}

打印结果：

waiter waiting to get notified at time:1552817803526
waiter1 waiting to get notified at time:1552817803526
All the threads are started
notifier started
waiter1 获取到msg的消息信息了:1552817804528
waiter1 processed: notifier waiter的名称
waiter 获取到msg的消息信息了:1552817804528
waiter processed: notifier waiter的名称

在讲解wait和notify，notifyall之前首先需要理解moniter的概念。

关于什么是moniter？

这个名词如果第一次听说，可能会比较迷。暂且可以理解为java虚拟机给每个对象的class字节码都设置了一个监听器Monitor。

如果有了解过synchronized底层的实现方式，应该会对entry-set和wait-set这两个名词比较熟悉。

我们可以把Monitor想象成一个保险箱，里面专门存放一些需要被保护的数据。Monitor每次只允许一个线程进入，当一个线程需要访问受保护的数据（即需要获取对象的Monitor）时，它会首先在entry-set入口队列中排队（这里并不是真正的按照排队顺序），如果没有其他线程正在持有对象的Monitor，那么它会和entry-set队列和wait-set队列中的被唤醒的其他线程进行竞争（即通过CPU调度），选出一个线程来获取对象的Monitor，执行受保护的代码段，执行完毕后释放Monitor，如果已经有线程持有对象的Monitor，那么需要等待其释放Monitor后再进行竞争。

再说一下wait-set队列。当一个线程拥有Monitor后，经过某些条件的判断（比如用户取钱发现账户没钱），这个时候需要调用Object的wait方法，线程就释放了Monitor，进入wait-set队列，等待Object的notify方法（比如用户向账户里面存钱）。当该对象调用了notify方法或者notifyAll方法后，wait-set中的线程就会被唤醒，然后在wait-set中被唤醒的线程和entry-set中的线程一起通过CPU调度来竞争对象的Monitor，最终只有一个线程能获取对象的Monitor。

wait()、notify()和notifyAll()都是Object类中的方法，在jdk中都是属于本地调用函数：

public class Object {
     ...
     private transient int shadow$_monitor_;
     public final native void notify();
     public final native void notifyAll();
     public final native void wait() throws InterruptedException;
     public final void wait(long millis) throws InterruptedException {
         wait(millis, 0);
     }
    public final native void wait(long millis, int nanos) throws InterruptedException;
    ...
}

wait()

使用wait方法会让当前线程处于一个等待的装填，知道另外的线程调用notify或者notifyAll之后才会唤醒。在等待期间，该线程必须要放弃掉自身的moniter，（这里是强制释放锁，与sleep正好相反，sleep会占用moniter），然后该线程会被放入到等待队列中，直到接收到notify或者notifyall指令才会被唤醒。

notify()

使用notify方法可以将等待队列中的正在等待这个对象的moniter的线程唤醒，将其加入到同步队列中进行moniter的抢夺。

notifyAll()

调用notifyAll()方法能够唤醒所有正在等待这个对象的monitor的线程；

在旧版本的jdk中，线程之间的通信主要局限于Object类里面的notify和wait等系列方法，wait函数不能够单独使用，必须是在synchronized 下才能使用，而且wait()必须要通过notify()或者notifyAll()的方法才能进行唤醒，并且wait-set只有一个，过于单一，因此缺乏一定的灵活性。

除了使用wait，notify，notifyall之外来实现线程的唤醒和阻塞之外，还有其他的工具类可以提供类似的功能。例如说LockSupport里面的park和unpark函数，可以提供对于线程状态的控制功能。

代码案例：

import java.util.concurrent.locks.LockSupport;

/**
 * @author idea
 * @data 2019/3/17
 */
class ParkThread implements Runnable{


    @Override
    public void run() {
        System.out.println("ParkThread is run");
        //堵塞当前线程！
        LockSupport.park();
        System.out.println("ParkThread is over");
    }
}

class UnParkThread implements Runnable{

    private Thread thread;

    public UnParkThread(Thread thread) {
        this.thread = thread;
    }

    @Override
    public void run() {
        System.out.println("UnParkThread is run");
        //堵塞该线程！
        LockSupport.unpark(thread);
        System.out.println("UnParkThread is over");
    }
}

public class LockSupportDemo2 {


    public static void main(String[] args) {
        Thread parkThread=new Thread(new ParkThread());
        System.out.println("-----------");
        Thread unparkThread=new Thread(new UnParkThread(parkThread));
        parkThread.start();
        unparkThread.start();
    }

}

同时LockSupport也提供了很多灵活操作的api

// 返回提供给最近一次尚未解除阻塞的 park 方法调用的 blocker 对象，如果该调用不受阻塞，则返回 null。
 static Object getBlocker(Thread t)
 // 为了线程调度，禁用当前线程，除非许可可用。
 static void park()
 // 为了线程调度，在许可可用之前禁用当前线程。
 static void park(Object blocker)
 // 为了线程调度禁用当前线程，最多等待指定的等待时间，除非许可可用。
 static void parkNanos(long nanos)
 // 为了线程调度，在许可可用前禁用当前线程，并最多等待指定的等待时间。
static void parkNanos(Object blocker, long nanos)
// 为了线程调度，在指定的时限前禁用当前线程，除非许可可用。
static void parkUntil(long deadline)
// 为了线程调度，在指定的时限前禁用当前线程，除非许可可用。
static void parkUntil(Object blocker, long deadline)
// 如果给定线程的许可尚不可用，则使其可用。
static void unpark(Thread thread)

Condition

Condition是在java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition的await()、signal()这种方式实现线程间协作更加安全和高效。因此通常来说比较推荐使用Condition，有了解过阻塞队列底层实现的朋友应该会知道，阻塞队列实际上是使用了Condition来模拟线程间协作。

• Condition是个接口，基本的方法就是await()和signal()方法

• Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition() 

• 调用Condition的await()和signal()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock之间才可以使用

• Conditon中的await()对应Object的wait()；

• Condition中的signal()对应Object的notify()；

• Condition中的signalAll()对应Object的notifyAll()。

上边我们讲解了基于wait、notify实现的等待、通知模式，但是这种模式的实现缺乏一定的灵活性，那么接下来的这段内容主要是依靠Condition来实现生产消费模式：

生产者队列：

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author idea
 * @data 2019/2/17
 */
public class ProductQueue<T> {

    private final T[] items;

    private final Lock lock = new ReentrantLock();
    private Condition notFull = lock.newCondition();
    private Condition notEmpty = lock.newCondition();

    private int head;
    private int tail;
    private int count;

    public ProductQueue(int maxSize) {
        items = (T[]) new Object[maxSize];
    }

    public ProductQueue() {
        this(10);
    }

    public void put(T t) {
        lock.lock();
        try {
            while (count == getCapacity()) {
                //有点类似于Object.wait
                //队列满了则不写入
                System.out.println("资源已生产完毕，材料不足了");
                notFull.await();
            }
            items[tail] = t;
            if (++tail == getCapacity()) {
                tail = 0;
            }
            count++;
            //有点类似于Object.notifyAll
            notEmpty.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }


    public T take() {
        lock.lock();
        try {
            while (count == 0) {
                //相当于Object.wait
                System.out.println("资源已经抢夺完毕");
                notEmpty.await();
            }
            T out = items[head];
            //GC
            items[head] = null;
            if (++head == getCapacity()) {
                head = 0;
            }
            --count;
            notFull.signalAll();
            System.out.println("抢到了资源：");
            return out;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            lock.unlock();
        }
    }

    public int size() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }

    public int getCapacity() {
        return items.length;
    }


    public static void main(String[] args) throws InterruptedException {
        ProductQueue<Integer> productQueue = new ProductQueue<>();
        Thread provider = new Thread(new Provider(productQueue));
        //验证队列满了是否可以再加入
        provider.start();
        CountDownLatch countDownLatch = new CountDownLatch(1);
        Consumer[] consumers = new Consumer[100];
        //验证队列为空是否可以进行消费
        for (int i = 0; i < 100; i++) {
            consumers[i] = new Consumer(productQueue, countDownLatch);
            consumers[i].start();
        }
        System.out.println("消费者创建完毕");
        countDownLatch.countDown();
    }

}

生产者：

/**
 * @author idea
 * @data 2019/2/17
 */
public class Provider implements Runnable {

    private ProductQueue<Integer> productQueue;

    public Provider(ProductQueue productQueue) {
        this.productQueue = productQueue;
    }

    @Override
    public void run() {
        while (true){
            for(int i=0;i<10;i++){
                System.out.println("------------生产了资源:"+i);
                productQueue.put(i);
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


    }
}

消费者：

import java.util.concurrent.CountDownLatch;

/**
 * @author idea
 * @data 2019/2/17
 */
public class Consumer extends Thread {

    private ProductQueue<Integer> productQueue;

    private CountDownLatch countDownLatch;

    public Consumer(ProductQueue productQueue,CountDownLatch countDownLatch) {
        this.countDownLatch=countDownLatch;
        this.productQueue = productQueue;
    }

    @Override
    public void run() {
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        while (true){
            Integer number = productQueue.take();
        }

    }
}

与Object里面的wait和notify相比，Condition里面还包含了很多有趣的知识点，由于篇幅有限，关于Condition在aqs中源码的实现部分，以后我会专门抽空来写一篇文章进行总结。