多執行緒（五）執行緒協作、執行緒池

• 多執行緒（五）執行緒協作、執行緒池
  • 執行緒協作
    • 生產者消費者問題
    • 生產者消費者問題的解決方式
      • 解決方式一：管程法
      • 解決方式二：訊號燈法
  • 執行緒池
    • 執行緒池相關類：
  • 程式碼例項
    • 管程法
    • 訊號燈法
    • 執行緒池

執行緒協作

生產者消費者問題

• 執行緒同步問題，生產者和消費者共享同一個資源，並且生產者和消費者之間相互依賴，互為條件

  • 生產者：沒有生產產品之前，要通知消費者；生產了產品之後，要通知消費者消費
  • 消費者：消費之後，通知生產者已經結束消費，需要生產新的產品

• 生產者消費者問題中，僅有synchronized是不夠的

  • synchronized可阻止併發更新同一個共享資源，實現了同步
  • synchronized不能用來實現不同執行緒之間的訊息傳遞（通訊）

• Java提供的（Object類）解決執行緒之間的通訊問題的方法：

  方法名	作用
  wait()	表示執行緒一直等待，直到其他執行緒通知，與sleep不同，會釋放鎖
  wait(long timeout)	指定等待的毫秒數
  notify()	喚醒一個處於等待狀態的執行緒
  notifyAll()	喚醒同一個物件上所有呼叫wait()方法的執行緒，優先級別高的執行緒優先排程

生產者消費者問題的解決方式

解決方式一：管程法

• 生產者將生產好的資料放入緩衝區，消費者從緩衝區中拿出資料
  • 生產者：負責生產資料的模組（可能是方法，物件，執行緒，程序）
  • 消費者：負責處理資料的模組（可能是方法，物件，執行緒，程序）
  • 緩衝區：消費者不能直接使用生產者的資料，他們之間有個“緩衝區”

解決方式二：訊號燈法

• 通過訊號燈判斷是否執行（通過True和False判斷是否執行）

執行緒池

• 背景：由於經常建立和銷燬、使用量特別大的資源，比如併發情況下的執行緒，對效能影響很大，所以用到執行緒池
• 提前建立好多執行緒，放入執行緒池中，使用時直接獲取，使用完放回池中。
• 避免頻繁建立銷燬，實現重複利用
• 執行緒管理：
  • corePoolSize：核心池的大小
  • maximumPoolSize：最大執行緒數
  • keepAliveTime：執行緒沒有任務時最多保持多長時間後會終止

執行緒池相關類：

• ExecutorService和Executors

  • ExecutorService(介面)：

    • ExecutorService是執行緒池介面

    • 子類：ThreadPoolExecutor

    • 方法

      void execute(Runnable command)//執行任務/命令,沒有返回值，一般用來執行Runnable
      

      <T>Fture<T>submit(Callable<T>tasks)//執行任務，有返回值，一般用來執行Callable
      

      void shutdown()//關閉連線池
      

  • Executors：

    工具類、執行緒池的工廠類，用於建立並返回不同型別的執行緒池

• ExecutorService是一個介面，通過Executors工具類建立池子

程式碼例項

管程法

• 吃雞與生產雞

//測試:生產者消費者模型-->利用緩衝區解決：管程法
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;
    }
    //生產
    @Override
    public void run() {
        for (int i = 0; i < 30; i++) {
            System.out.println("生產了"+i+"號雞-----》第"+(i+1)+"只雞");
            container.push(new Chicken(i));
        }
    }
}
//消費者
class Consumer extends Thread{
    SynContainer container;
    public Consumer(SynContainer container){
        this.container=container;
    }
    @Override
    public void run() {
        for (int i = 0; i < 30; i++) {
            System.out.println("消費了"+container.pop().id+"號雞------》消費的第"+(i+1)+"只雞");
        }
    }
}
//產品
class Chicken{
    int id;//產品編號
    public Chicken(int id){
        this.id=id;
    }
}
//緩衝區
class SynContainer{
    //容器大小
    Chicken[] chickens=new Chicken[10];
    //容器計數
    int count=0;
    //生產者放入產品
    public synchronized void push(Chicken chicken){
        //如果容器滿了，就需要等待消費者
        if(count==chickens.length){
            //生產等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果沒有滿，則繼續消費
        chickens[count]=chicken;
        count++;
        //通知消費者消費
        this.notify();
    }
    //消費者消費產品
    public synchronized Chicken pop(){
        //判斷能否消費
        //如果不能消費
        if(count==0){
            //等待生產者生產，消費者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消費
        count--;
        //吃一個雞，拿一個雞
        Chicken chicken=chickens[count];
        //吃完了，通知生產者生產
        this.notify();
        return chicken;
    }
}
//輸出：
生產了0號雞-----》第1只雞
生產了1號雞-----》第2只雞
生產了2號雞-----》第3只雞
生產了3號雞-----》第4只雞
生產了4號雞-----》第5只雞
生產了5號雞-----》第6只雞
生產了6號雞-----》第7只雞
生產了7號雞-----》第8只雞
生產了8號雞-----》第9只雞
生產了9號雞-----》第10只雞
生產了10號雞-----》第11只雞
生產了11號雞-----》第12只雞
消費了9號雞------》消費的第1只雞
消費了10號雞------》消費的第2只雞
生產了12號雞-----》第13只雞
消費了11號雞------》消費的第3只雞
生產了13號雞-----》第14只雞
消費了12號雞------》消費的第4只雞
生產了14號雞-----》第15只雞
消費了13號雞------》消費的第5只雞
生產了15號雞-----》第16只雞
消費了14號雞------》消費的第6只雞
生產了16號雞-----》第17只雞
消費了15號雞------》消費的第7只雞
生產了17號雞-----》第18只雞
消費了16號雞------》消費的第8只雞
生產了18號雞-----》第19只雞
消費了17號雞------》消費的第9只雞
生產了19號雞-----》第20只雞
消費了18號雞------》消費的第10只雞
生產了20號雞-----》第21只雞
消費了19號雞------》消費的第11只雞
生產了21號雞-----》第22只雞
消費了20號雞------》消費的第12只雞
生產了22號雞-----》第23只雞
消費了21號雞------》消費的第13只雞
生產了23號雞-----》第24只雞
消費了22號雞------》消費的第14只雞
生產了24號雞-----》第25只雞
消費了23號雞------》消費的第15只雞
生產了25號雞-----》第26只雞
消費了24號雞------》消費的第16只雞
生產了26號雞-----》第27只雞
消費了25號雞------》消費的第17只雞
生產了27號雞-----》第28只雞
消費了26號雞------》消費的第18只雞
生產了28號雞-----》第29只雞
消費了27號雞------》消費的第19只雞
生產了29號雞-----》第30只雞
消費了28號雞------》消費的第20只雞
消費了29號雞------》消費的第21只雞
消費了8號雞------》消費的第22只雞
消費了7號雞------》消費的第23只雞
消費了6號雞------》消費的第24只雞
消費了5號雞------》消費的第25只雞
消費了4號雞------》消費的第26只雞
消費了3號雞------》消費的第27只雞
消費了2號雞------》消費的第28只雞
消費了1號雞------》消費的第29只雞
消費了0號雞------》消費的第30只雞

訊號燈法

• 有節目時觀眾觀看，沒有節目時觀眾不看，演員準備

public class TestPc2 {
    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;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; 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;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            tv.watch();
        }
    }
}
//產品--》節目
class TV{
    //演員表演，觀眾等待flag=true
    //觀眾觀看，演員等待flag=false
    String 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;
    }
}
//輸出：
演員表演了：節目一
觀看了：節目一
演員表演了：節目二
觀看了：節目二
演員表演了：節目一
觀看了：節目一
演員表演了：節目二
觀看了：節目二
演員表演了：節目一
觀看了：節目一
演員表演了：節目二
觀看了：節目二
演員表演了：節目一
觀看了：節目一
演員表演了：節目二
觀看了：節目二
演員表演了：節目一
觀看了：節目一
演員表演了：節目二
觀看了：節目二

執行緒池

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());
    }
}
//輸出：
pool-1-thread-2
pool-1-thread-3
pool-1-thread-1
pool-1-thread-4