Java线程通信-生产者消费者问题

线程通信示例——生产者消费者问题

这类问题描述了一种情况,假设仓库中只能存放一件产品,生产者将生产出来的产品放入仓库,消费者将仓库中的产品取走消费.假设仓库中没有产品,则生产者可以将 产品放入仓库,有产品,则停止生产并等待,直到仓库中的产品被消费这取走为止. 如果仓库中放油产品,则消费者可以将产品取走消费,否则停止消费并等待,直到 仓库中再次放入产品为止. 显然,这是一个同步问题,生产者和消费这共享同一资源, 并且生产者和消费这之间彼此依赖,互为条件向前推进.Java提供了3个方法解决了线程间的通信问题,分别是wait() notify() 和 notifyAll()
* (1)调用wait()方法: 使调用该方法的线程释放共享资源的锁,然后从运行状态退出, 进入等待队列,直到被再次唤醒
* (2)调用notify()方法: 唤醒等待队列中第一个等待同一共享资源的线程,并使该线程退出等待,进入就绪状态
* (3)调用notifyAll()方法: 使所有正在等待队列中同一共享资源的线程从等待状态退出,此时优先级最高的那个线程最先执行

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

 package com.iotek.productconsumerdemo;

 import java.util.LinkedList;

 public class ProductorConsumerDemo {

     /**
      * 线程通信-wait() notify() notifyAll()
      * 在现实应用中，很多时候需要让那个多个线程按照i定的次序来访问共享资源，例如经典的生产者消费者问题：
      * 这类问题描述了这样一种情况，假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者
      * 将仓库中的产品取走消费，如果仓库中没有产品，在生产者可以将产品放入仓库，否则停止生产并等待，直到
      * 仓库中的产品被消费这取完为止，如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，
      * 直到仓库中再次放入产品为止
      * @param args
      *
      */
     public static void main(String[] args) {
         Basket basket = new Basket();
         Productor productor = new Productor(basket);//创建生产者对象
         Consumer consumer = new Consumer(basket);//创建消费者对象
         productor.start();  //生产者启动生产
         consumer.start();   //消费者开始消费
     }

 }

 class Consumer extends Thread {
     private Basket basket = null;

     public Consumer(Basket basket) {
         this.basket = basket;
     }
     @Override
     public void run() {
         basket.popApple();  //消费者从篮子里取苹果
     }
 }

 class Productor extends Thread {
     private Basket basket = null;

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

     @Override
     public void run() {
         basket.pushApple(); // 生产者向篮子里放苹果
     }
 }

 // 篮子类，用来存放苹果(需要一个容器来存放，频繁存取，用LinkedList)，或者取苹果
 class Basket {
     private LinkedList<Apple> basket = new LinkedList<Apple>();

     // 放四轮苹果
     public synchronized void pushApple() {
         // synchronized 加锁，放苹果的时候不能取苹果
         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私有的
     /* public */private void push(Apple apple) {
         // 如果篮子里已经有5个苹果了，就等待并通知消费者来消费
         if (basket.size() == 5) {
             try {
                 wait();// 等待，并释放当前对象的锁
                 /* 注意！！！调用wait()方法进入等待的线程，必须要通过其他线程调用notify()或notifyAll()方法来唤醒 */
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         // 如果没满5个苹果，那么就继续放苹果
         try {
             Thread.sleep(500);// 每隔500ms放一个苹果
             // sleep()使当前线程每隔设定的休眠时间后，就自动启动线程
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         basket.addFirst(apple);// 存放苹果
         System.out.println("存放:" + apple.toString());
         notify();// 通知消费者来消费
     }

     // 从篮子中取苹果
     /* public */private void pop() {
         // 当篮子中苹果数为0 的时候就等待并通知生产者来生产
         if (basket.size() == 0) {
             try {
                 wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         // 如果篮子中苹果不为0，那么就消费，每隔一定间隔，消费一个苹果
         try {
             Thread.sleep(500);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         Apple apple = basket.removeFirst();// 取出一个苹果
         System.out.println("吃掉：" + apple.toString());
         notify(); // 通知生产者来生产：notify()方法唤醒等待队列中第一个等待同一共享资源的线程,并使该线程进入就绪状态

     }
 }

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

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

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