多线程——线程通信

在现实应用中，很多时候需要让多个线程按照一定的次序来访问共享资源。例如，经典的生产者和消费者问题。

① 这类问题描述了这样一种情况，假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中的产品取走消费。如果仓库中没有产品，则生产者可以将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止。如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，知道仓库中再次放入产品为止。

② 显然，这是一个同步问题，生产者和消费者共享同一资源，并且，生产者和消费者之间彼此依赖，互为条件向前推进。

该如何变成程序来解决这个问题呢？

传统的思路是利用循环检测的方式来实现，通过重复检查某一个特定条件是否成立来决定线程的推进顺序。

比如，一旦生产者生产结束，它就继续利用循环检测来判断仓库中的产品是否被消费者消费，而消费者也是在消费结束后就会立即使用循环检测的方式来判断仓库中是否又放进产品。显然，这些操作是很耗CPU资源的，不值得提倡。

 

有没有更好的方法来解决这类问题呢？

Java提供了3个重要的方法巧妙解决线程间的通信问题。这3个方法分别是：wait()、notify()和notifyAll()。

① wait()：可以使调用该方法的线程释放共享资源的锁，然后从运行状态退出，进入等待队列，直到被再次唤醒。

② notify()：可以唤醒等待队列中第一个等待同一共享资源的线程，并使该线程退出等待队列，进入可运行状态。

③ notifyAll()：可以使所有正在等待队列中同一共享资源的线程从等待队列状态退出，进入可运行状态，此时，优先级最高的那个线程最先执行。 

 

示例：生产者采摘5个苹果放入篮子中，消费者拿走篮子中的5个苹果后，生产者再采摘5个放入篮子…共进行4次。

代码如下：

//消费者线程
class Consumer extends Thread {
    private Basket basket = null;

    public Consumer(Basket basket) {
        super();
        this.basket = basket;
    }

    @Override
    public void run() {
        basket.popApple();
    }

}

//生产者线程
class Productor extends Thread {
    private Basket basket = null;

    public Productor(Basket basket) {
        super();
        this.basket = basket;
    }

    @Override
    public void run() {
        basket.pushApple();
    }

}

//篮子类
class Basket {
    private LinkedList<Apple> basket = new LinkedList<Apple>();

    // 放4轮苹果
    public synchronized void pushApple() {
        for (int i = 0; i < 20; i++) {
            Apple apple = new Apple(i);
            push(apple);
        }
    }

    // 取4轮苹果
    public synchronized void popApple() {
        for (int i = 0; i < 20; i++) {
            pop();
        }
    }

    // 向篮子中放苹果
    private void push(Apple apple) {
        // 当篮子中存放了5个苹果就等待并通知消费者来消费
        if (basket.size() == 5) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }// 等待并释放当前资源的锁
        }
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        basket.addFirst(apple);
        System.out.println("存放：" + apple.toString());
        notify();// 通知消费者来消费
    }

    // 向篮子中取苹果
    private void pop() {
        // 当篮子中苹果为0时就等待并通知生产者来生产
        if (basket.size() == 0) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }// 等待并释放当前资源的锁
        }
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Apple apple = basket.removeFirst();
        System.out.println("吃掉：" + apple.toString());
        notify();// 通知生产者来生产
    }
}

// 苹果类
class Apple {
    private int id;

    public Apple(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "苹果：" + (id + 1);
    }
}

主方法：

        Basket basket=new Basket();
        Productor productor=new Productor(basket);
        Consumer consumer=new Consumer(basket);
        productor.start();
        consumer.start();

运行结果：

生产者逐个生产5个苹果1-5;消费者逐个消费5个苹果5-1;
生产者逐个生产5个苹果6-10;消费者逐个消费5个苹果10-6;
生产者逐个生产5个苹果11-15;消费者逐个消费5个苹果15-11;
生产者逐个生产5个苹果16-20;消费者逐个消费5个苹果20-16;