JavaSE（2）05 多线程--线程通信

多线程

线程通信

生产者消费者问题

• 这是一个线程同步问题，生产者和消费者共享同一个资源，并且消费者和生产者之间相互依赖，互为条件。
• 对于生产者，没有生产商品之前，要通知消费者等待，而生产了商品之后，又需要马上通知消费者来消费；
• 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费
• 生产者消费者之间仅有synchronized是不够的
  • synchronized可以阻止并发更新同一个共享资源，实现了同步
  • synchronized不能用来实现不同线程之间的消息传递（通信）
    

解决方式1 管程法

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

//生产者消费者模型--->利用缓冲区解决：管程法
//生产者、消费者、产品、缓冲区
public class PCdemo01 {
    public static void main(String[] args) {
        SynContainer container=new SynContainer();
        new Productor(container).start();
        new Costumer(container).start();
    }
}
 class Productor extends Thread{
     SynContainer container;
     public Productor(SynContainer container) {
         this.container = container;
     }

     @Override
     public void run() {
         for (int i = 0; i < 100; i++) {
             System.out.println("生产了第"+(i+1)+"只鸡");
             container.pushChickens(new Chicken(i));
         }
     }
 }

 class Costumer extends Thread{
     SynContainer container;
     public Costumer(SynContainer container) {
         this.container = container;
     }

     @Override
     public void run() {
         for (int i = 0; i < 100; i++) {
             System.out.println("消费了第"+container.popChickens().id+"只鸡");
             container.popChickens();
         }
     }
 }

 class Chicken{
    int id;

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


 class SynContainer{
    //容器大小
     Chicken[] chickens=new Chicken[10];
     int count=0;
     //生产者放入产品
     public synchronized void pushChickens(Chicken chicken){
         //如果容器满了，就需要等待消费者消费
         if(count==10){
             //通知消费者消费，生产等待
             try {
                 this.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }else{
             chickens[count]=chicken;
             count++;
             this.notifyAll();
         }

     }


     //消费者取产品
     public synchronized Chicken popChickens(){
         if(count==0){
             //等待生产者生成
             try {
                 this.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         //如果可以消费
         count--;
         Chicken chicken=chickens[count];
         //吃完了通知生产者生产
         this.notifyAll();
         return chicken;
     }
 }

解决方式2 信号灯法

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

线程池

• 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大
• 思路：提前创建好对个线程，放入线程池中，使用时直接获取，使用完后直接放回线程池中，可以避免频繁创建销毁，实现重复利用
• 好处：
  - 提高响应速度（减少了创建新线程的时间）
  - 降低资源消耗（重复利用线程池中的线程，不需要每次都创建）
  - 便于线程管理
• corePoolSize:核心池大小
• maximumPoolSize:最大线程数
• keepAliveTime：线程没有任务时最多保持多长时间后终止
• ExecutorService：真正的线程池接口。
• Executors：工具类，线程池的工厂类，用于创建并返回不同类型的线程池

//测试线程池
public class TestPool {
    public static void main(String[] args) {
        //1、创建服务创建线程池
        //newFixedThreadPool 参数为线程池大小
        ExecutorService service=Executors.newFixedThreadPool(10);
        //2、执行 Runnable执行execute（）  Callable执行submit（）
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        //3、关闭连接
        service.shutdown();
    }
}
class MyThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"\t 执行"+i);
        }
    }
}