Java线程协作

目录

线程协作

生产者消费者模式

线程通信-分析

线程池

---

线程协作

生产者消费者模式

• 应用场景：生产者和消费者问题

  • 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费

  • 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止

  • 如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止

  • 

线程通信-分析

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

• 对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又需要马上通知消费者消费

• 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费

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

  • synchronized可阻止并发更新同一个共享资源，实现了同步

  • synchronized不能用来实现不同线程之间的消息传递（通信）

• Java提供了几个方法解决线程之间的通信问题

  • 

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

解决方式1

并发协作模型“生产者/消费者模式”--->管程法

• 消费者：负责生产数据的模块（可能是方法，对象，线程，进程）

• 消费者：负责处理数据的模块（可能是方法，对象，线程，进程）

• 缓冲区：消费者不能直接使用生产者的数据，他们之间有个缓冲区

生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据

解决方式2

• 并发协作模型“生产者/消费者模式”--->信号灯法

演示：信号灯法

 package JavaSE;
 ​
 //演示：录制节目，演员录制，观众等待
 public class TestPc {
     public static void main(String[] args) {
         TV tv = new TV();
         new Actor(tv).start();
         new Watcher(tv).start();
     }
 }
 ​
 //生产者-->演员
 class Actor extends Thread{
     TV tv;
 ​
     public Actor(TV tv) {
         this.tv = tv;
     }
 ​
     @Override
     public void run() {
         for (int i = 0; i < 20; i++) {
             if(i%2==0){
                 this.tv.act("快乐大本营");
             }else {
                 this.tv.act("抖音：记录美好生活");
             }
         }
     }
 }
 ​
 //消费者-->观众
 class Watcher extends  Thread{
     TV tv;
 ​
     public Watcher(TV tv) {
         this.tv = tv;
     }
 ​
     @Override
     public void run() {
         for (int i = 0; i < 20; i++) {
             tv.watch();
         }
     }
 }
 ​
 //产品-->节目
 class TV{
     //演员表演，观众等待 T
     //观众观看，演员等待 F
     String voice;//表演的节目
     boolean flag = true;
 ​
     //演员表演
     public synchronized void act(String voice){
         if(!flag){
             try {
                 this.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
 ​
         System.out.println("演员表演了："+voice);
         //通知观众观看
         this.notify();//通知唤醒
         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 executor(Runnable command):执行任务/命令，没有返回值，一般用来执行Runnable

  • <T>Future<T>submit(Callable<T>task):执行任务，有返回值，一般又来执行Callable

  • void shutdown（）：关闭连接池

• Executor：工具类，线程池的工厂类，用于创建并返回不同类型的线程池

演示：线程池

 package JavaSE;
 ​
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 ​
 //测试线程池
 public class TestPool {
 ​
     public static void main(String[] args) {
         //1.创建服务，创建线程池
         //newFixedThreadPool    参数为：线程池大小
         ExecutorService service = Executors.newFixedThreadPool(10);
 ​
         //执行
         service.execute(new MyThread());
         service.execute(new MyThread());
         service.execute(new MyThread());
         service.execute(new MyThread());
 ​
         //2.关闭连接
         service.shutdown();
 ​
     }
 }
 ​
 class MyThread implements Runnable{
     @Override
     public void run() {
             System.out.println(Thread.currentThread().getName());
     }
 }