线程协作——生产者消费者问题

本文主要是介绍线程协作——生产者消费者问题，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

生产者消费者问题

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

方法名	作用
wait()	表示线程一直等待，直到其它线程通知，与sleep不同，会释放锁
wait(long timeout)	指定等待的毫秒数
notify()	唤醒一个处于等待状态的线程
notifyAll()	唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度

注意：均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常

管程法

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

方法一：管程法

//管程法
public class TestPC{public static void main(String[] args){SynContainer container = new SynContainer();new Productor(container).start();new Consumer(container).start();}
}//生产者
class Productor extends Thread{SynContainer container;public Productor(SynContainer container){this.container = container;}//生产@Overridepublic void run(){for(int i = 0; i < 100; i++){container.push(new Product(i));System.out.println("生产了" + i + "只鸡");}}
}//消费者
class Consumer extends Thread{SynContainer container;public Consumer(SynContainer container){this.container = container;}//消费@Overridepublic void run(){for(int i = 0; i < 100; i++){System.out.println("消费了第" + container.pop().id + "只鸡");}}
}//产品
class Product{int id; //产品编号public Product(int id){this.id = id;}
}//缓冲区
class SynContainer{//需要一个容器大小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();}}//如果没有满，放入商品products[count] = product;count++;//通知消费者消费this.notifyAll(); }//消费者消费产品public synchronized Product pop(){//判断能否消费if(count == 0){//通知生产者生产，消费者等待try{this.wait();}catch(InterruptedException e){e.printStackTrace();}}//如果可以消费count--;Product product = products[count];//通知生产者生产this.notifyAll();return product;}
}

方法二：信号灯法

//信号灯法：标志位解决
public class TestPC{public static void main(String[] args){TV tv = new TV();new Player(tv).start();new Watcher(tv).start();}
}//生产者--->演员
class Player extends Thread{TV tv;public Player(TV tv){this.tv = tv;}@Overridepublic void run(){for(int i = 0; i < 20; i++){if(i%2 == 0){this.tv.play("快乐大本营");}else{this.tv.play("抖音");}}}
}//消费者--->观众
class Watcher extends Thread{TV tv;public Watcher(TV tv){this.tv = tv;}@Overridepublic void run(){for(int i = 0; i < 20; i++){tv.watch();}}
}//产品--->节目
class TV{//演员表演，观众等待 T//观众观看，演员等待 FString voice; //表演的节目boolean flag = true;//表演public synchronized void play(String voice){if(!flag){try{this.wait();}catch(InterruptedException e){e.printStackTrace();}}System.out.println("演员表演了：" + voice);//通知观众观看this.notifyAll();this.voice = voice;this.flag = !this.flag;}//观看public synchronized void watch(){if(flag){try{this.wait();}catch(InterruptedException e){e.printStackTrace();}}System.out.println("观众观看了：" + voice);//通知演员表演this.notifyAll();this.flag = !this.flag;}
}

线程池
- 提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用
- 好处：
  - 提高响应速度（减少了创建新线程的时间）
  - 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
  - 便于线程管理
    - corePoolSize：核心池的大小
    - maximumPoolSize：最大线程数
    - keepAliveTime：线程没有任务时最多保持多长时间后会终止
- JDK5.0起提供了线程池相关API：ExecutorService和Executors
- ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
  - void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
  - < T > Future< T > submit(Callable< T > task)：执行任务，有返回值，一般用来执行Callable
  - void shutdown()：关闭连接池
- Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
```
//测试线程池
public class TestPool{public static void main(String[] args){//创建服务，创建线程池//newFixedThreadPool 参数为：线程池的大小ExecutorService service = Executors.newFixedThreadPool(10);service.execute(new MyThread());service.execute(new MyThread());service.execute(new MyThread());service.execute(new MyThread());//关闭连接service.shutdown();}
}class MyThread implements Runnable{@Overridepublic void run(){System.out.println(Thread.currentThread().getName());}
}
```