java多线程通信之等待唤醒机制

0概述

多线程间通信，其实就是多个线程操操作同一个资源，但是操作方式不同。典型实例有生产者和消费者，本文也通过实例来分析线程等待唤醒机制。

1相关API介绍

public final void notify()
唤醒在此对象监视器上等待的单个线程，如果所有线程都在此对象上等待，则会任意选择唤醒其中一个线程。
public final void wait()
当前线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。
“为了实现监视器的排他性监视能力，JVM为每一个对象和类都关联一个锁；锁住了一个对象，就是获得对象相关联的监视器”。
wait()，notify(),notifyAll(),这些方法都使用在同步代码块中，因为要对持有监视器的线程进行操作，所以要使用在同步中，因为只有同步才有锁。值得说明的是：等待和唤醒必须是同一个锁（必须为同一个对象）。由于锁可以是任意对象，所以可以被任意对象调用的方法定义在object类中。

2 实例分析

仓库类

//等待和唤醒都是this锁
public class Storage<T> {
    // 仓库最大存储量
    private final int MAX_SIZE = 1000;
    private int storageSize = 100;
    private Object[] data;
    private int top = 0;


    public Storage(int size) {
        size = size <= 0 ? storageSize : size;
        size = size > this.MAX_SIZE ? this.MAX_SIZE : size;
        this.storageSize = size;
        data = new Object[this.storageSize];
    }

    public int getStorageSize() {
        return storageSize;
    }

    public synchronized T pop() {
        while (top == 0) {
            try {
                //等待
                wait();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
        top--;
        T t = (T) data[top];
        //唤醒所有线程
        notifyAll();
        return t;
    }

    public synchronized void push(T t) {
        while (top == storageSize) {
            try {
                wait();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
        data[top++] = t;
        notifyAll();
    }

}

生产者

public class Producer implements Runnable {
    private Storage<String> storage;
    private volatile boolean breakLoop = false;

    public Producer(Storage<String> storage) {
        this.storage = storage;
    }

    @Override
    public void run() {
        int index = 1;
        while (true) {
            if (breakLoop) {
                break;
            }
            try {
                Thread.sleep(1000);
            } catch (Exception ex) {
                ex.printStackTrace();
            }
            storage.push("data:" + index);
            System.out.println("Producer data:" + index);
            index++;
        }
    }

    public void destroy() {
        this.breakLoop = true;
    }
}

消费者

public class Consumer implements Runnable {
    private Storage<String> storage;
    private volatile boolean breakLoop = false;

    public Consumer(Storage<String> storage) {
        this.storage = storage;
    }

    @Override
    public void run() {
        while (true) {
            if (breakLoop) {
                break;
            }
            try {
                Thread.sleep(1000);
            } catch (Exception ex) {
                ex.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "Consumer:" + storage.pop());
        }
    }

    public void destroy() {
        this.breakLoop = true;
    }
}

Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的 Condition 对象。

public class Storage<T> {
    // 仓库最大存储量
    private final int MAX_SIZE = 1000;
    private int storageSize = 100;
    private Object[] data;
    private int top = 0;
    private Lock lock = new ReentrantLock();
    private Condition producerCon = lock.newCondition();
    private Condition consumerCon = lock.newCondition();

    public Storage(int size) {
        size = size <= 0 ? storageSize : size;
        size = size > this.MAX_SIZE ? this.MAX_SIZE : size;
        this.storageSize = size;
        data = new Object[this.storageSize];
    }

    public int getStorageSize() {
        return storageSize;
    }

    public T pop() throws InterruptedException {
        T t = null;
        lock.lock();
        try {

            while (top == 0) {
                //消费者等待
                consumerCon.await();
            }
            top--;
            t = (T) data[top];
            //唤醒生产者
            producerCon.signal();

        } finally {
            lock.unlock();
        }
        return t;
    }

    public void push(T t) throws InterruptedException {
        lock.lock();
        try {
            while (top == storageSize) {
                //生产者等待
                producerCon.await();
            }
            data[top++] = t;
            //唤醒消费者
            consumerCon.signal();
        } finally {
            lock.unlock();
        }
    }

}