Java 多线程（Java.Thread）------ 线程协作（生产者消费者模式）

线程协作

• 应用场景：生产者消费者模式

  • 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费
  • 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止
  • 如果仓库中放有产品，则消费者可以将产品直接取走，否则停止消费并等待，直到仓库中再次放入产品为止

• 分析：这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者相互依赖，互为条件

• 在生产者和消费者问题中，仅有synchronized是不够的

  • synchronized可阻止并发更新同一个共享资源，实现了同步
  • synchronized不能用来实现不同线程之间的消息传递

• 解决线程之间通信问题的几个方法：

  • wait()：表示线程一直等待，直到其他线程通知，与sleep()不同，会释放锁
  • wait(long timeout)：指定等待的毫秒数
  • notify()：唤醒一个处于等待状态的线程
  • notifyAll()：唤醒同一个对象上所有调用wait()方法的线程，优先级高的线程优先调度
  • 以上方法都是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常IlledalMonitorStateException

• 解决方式一：并发协作模式“生产者/消费者模式”---->管程法

  • 生产者：负责生产数据的模块（可能是方法，对象，线程，进程）
  • 消费者：负责处理数据的模块(可能是方法，对象，线程，进程)
  • 缓冲区：消费者不能直接使用生产者的数据，他们之间有个缓冲区
  • 生产者将生产好的数据放到缓冲区，消费者从缓冲区拿出数据

package www.bh.c.threadtest;
//并发协作模式“生产者/消费者模式”---->管程法
public class PCTest {
    public static void main(String[] args) {
        Buffer buffer = new Buffer();
        new Producer(buffer).start();
        new Consumer(buffer).start();
    }
}
//生产者
class Producer extends Thread{
    Buffer buffer;
    public Producer(Buffer buffer){
        this.buffer=buffer;
    }
//生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            buffer.push(new Product(i));
            System.out.println("生产了"+i+"个产品");
        }
    }
}
//消费者
class Consumer extends Thread{
    Buffer buffer;
    public Consumer(Buffer buffer){
        this.buffer=buffer;
    }
//消费
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了---->"+buffer.pull().id+"个产品");
        }
    }
}

//产品
class Product{
    int id;
    public Product(int id) {
        this.id = id;
    }
}
//缓冲区
class Buffer{
    //缓冲区大小
    Product[] products=new Product[10];
    //缓冲区计数器
    int count=0;
    //生产者放入产品
    public synchronized void push(Product product){
             //如果缓冲区已满，通知消费者消费
        if (count==products.length){
           //等待消费，生产暂停
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else {
            //如果没有满，就继续放入产品
            products[count]=product;
            count++;
            //通知消费
            this.notifyAll();
        }
    }
    //消费者消费产品
    public synchronized Product pull(){
        //判断是否有产品可以消费
        if(count==0){
           //消费者等待生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count--;
        Product product=products[count];
        //消费完了，通知生产者生产
        this.notifyAll();
        return product;
    }
}