多執行緒Day04

东方语虑發表於2024-10-04
執行緒

死鎖

多個執行緒各自佔有一些共享資源，並且互相等待其它執行緒佔有的資源才能執行，而導致兩個或者多個執行緒都在等待對方釋放資源，都停止執行的情形，某一個同步塊同時擁有“兩個以上物件的鎖”，就可能會發生死鎖的問題

產生死鎖的四個必要條件：

  1. 互斥條件：一個資源每次只能被一個程序使用
  2. 請求與保持條件：一個程序因請求資源而阻塞時，對已獲得的資源保持不放
  3. 不剝奪條件：程序已獲得的資源，在未使用完之前，不能強行剝奪
  4. 迴圈等待條件：若干程序之間形成一種頭尾相接的迴圈等待資源關係
package com.dongfangyulv.thread;

//死鎖：多個執行緒互相抱著對方需要的資源，然後形成僵持
public class DeadLock {
    public static void main(String[] args) {
        Makeup g1 = new Makeup(0,"g1");
        Makeup g2 = new Makeup(0,"g2");

        g1.start();
        g2.start();
    }
}

//口紅
class Lipstick {

}

//鏡子
class Mirror {

}

class Makeup extends Thread {

    //需要的資源只有一份，用static來保證只有一份
    static Mirror mirror = new Mirror();
    static Lipstick lipstick = new Lipstick();

    int choice;//選擇
    String girlName;//化妝的人

    Makeup(int choice, String girlName) {
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {
        //化妝
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //化妝，互相持有對方的鎖，就是拿到對方的資源
    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (lipstick) {//獲得口紅的鎖
                System.out.println(this.girlName + "獲得口紅的鎖");
                Thread.sleep(1000);

                synchronized (mirror) {//一秒後想獲得鏡子
                    System.out.println(this.girlName + "獲得鏡子的鎖");
                }
            }
        }else {
            synchronized (mirror) {//獲得鏡子的鎖
                System.out.println(this.girlName + "獲得鏡子的鎖");
                Thread.sleep(2000);

                synchronized (lipstick) {//一秒後想獲得口紅
                    System.out.println(this.girlName + "獲得口紅的鎖");
                }
            }
        }
    }
}

Lock鎖

class A {
    private final ReentrantLock lock = new ReentrantLock();
    public void m() {
        lock.lock();
        try {
            //保證執行緒安全的程式碼
        }finally {
            lock.unlock();
            //如果同步程式碼有異常，要將unlock()寫入finally語句塊
        }
    }
}

synchronized 與 Lock 的對比

  • Lock是顯式鎖（手動開啟和關閉鎖）synchronized是隱式鎖，出了作用域自動釋放
  • Lock只有程式碼塊鎖，synchronized有程式碼塊鎖和方法鎖
  • 使用Lock鎖，JVM將花費較少的時間來排程執行緒，效能更好，並且具有更好的擴充套件性（提供更多的子類）
  • 優先使用順序：
    • Lock>同步程式碼塊（已經進入了方法體，分配了相應資源）>同步方法（在方法體之外）

執行緒協作

生產者消費者模式

應用場景：

  • 假設倉庫中只能存放一件產品，生產者將生產出來的產品放入倉庫，消費者將倉庫中產品取走消費
  • 如果倉庫中沒有產品，則生產者將產品放入倉庫，否則停止生產並等待，直到倉庫中的產品被消費者取走為止
  • 如果倉庫中放有產品，則消費者可以將產品取走消費，否則停止消費並等待，直到倉庫中再次放入產品為止

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

  • 對於生產者，沒有生產產品之前，要通知消費者等待，而生產了產品之後，又需要馬上通知消費者消費
  • 對於消費者，在消費之後，要通知生產者已經結束消費，需要生產新的產品以供消費
  • 在生產者消費者問題中僅有synchronized是不夠的
    • synchronized可阻止併發更新同一個共享資源，實現了同步
    • synchronized不能用來實現不同執行緒之間的訊息傳遞（通訊）
  • Java提供了幾個方法解決執行緒之間的通訊問題
    • wait( ) 表示執行緒一直等待，直到其他執行緒通知，與sleep不同，會釋放鎖
    • wait(long timeout) 指定等待的毫秒數
    • notify( ) 喚醒一個處於等待狀態的執行緒
    • notifyAll( ) 喚醒同一個物件上所有呼叫wait( )方法的執行緒，優先順序別高的執行緒優先排程
    • 均是Object類的方法，都只能在同步方法或者同步程式碼塊中使用，否則會丟擲異常
  • 解決方法：
    • 管程法：生產者將生產好的資料放入緩衝區，消費者從緩衝區拿出資料
    • 訊號燈法

管程法

package com.dongfangyulv.senior;

//測試生產者消費者模型，利用緩衝區解決：管程法

//生產者，消費者，產品，緩衝區
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 < 100; i++) {
            container.push(new Apple(i));
            System.out.println("生產了" + i + "個蘋果");
        }
    }
}

//消費者
class Consumer extends Thread{
    SynContainer container;
    public Consumer(SynContainer container) {
        this.container = container;
    }
    //消費
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消費了" + container.pop().id + "個蘋果");
        }
    }
}

//產品
class Apple {
    int id;//產品編號
    public Apple(int id) {
        this.id = id;
    }
}

//緩衝區
class SynContainer {
    //需要一個容器大小
    Apple[] apples = new Apple[10];
    //容器計數器
    int count = 0;
    //生產者放入產品
    public synchronized void push(Apple apple) {
        //如果容器滿了，就需要等待消費者消費
        if (count == apples.length) {
            //通知消費者消費，生產者等待
        }
        //如果容器沒有滿，我們就需要丟入產品
        apples[count] = apple;
        count++;
        //可以通知消費者消費了
        this.notifyAll();
    }
    //消費者取出產品
    public synchronized Apple pop() {
        //判斷能否消費
        if (count == 0) {
            //等待生產者生產，消費者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消費
        count--;
        Apple apple = apples[count];

        //通知生產者生產
        return apple;
    }
}

訊號燈法

package com.dongfangyulv.senior;

//測試生產者消費者問題2：訊號燈法，標誌位解決

public class TestPC2 {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Wacther(tv).start();
    }
}

//生產者-->演員
class Player extends Thread{
    TV tv;
    public Player(TV tv){
        this.tv = tv;
    }

    @Override
    public void run(){
        for (int i = 0; i < 20; i++) {
            if (i%2==0) {
                this.tv.play("節目");
            }else {
                this.tv.play("廣告");
            }
        }
    }
}

//消費者-->觀眾
class Wacther extends Thread{
    TV tv;
    public Wacther(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 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：執行緒沒有任務時最多保證多長時間後會終止
  • 執行緒池相關API：ExecutorService和Executors
  • ExecutorService：真正的執行緒池介面，常見子類ThreadPoolExecutor
    • void execute (Runnable command)：執行任務/命令，沒有返回值，一般用來執行Runnable
    • Futuresubmit(Callabletask)：執行任務，有返回值，一般用來執行Callable
    • void shutdown( )：關閉連線池
  • Executors：工具類、執行緒池的工廠類，用於建立並返回不同型別的執行緒池

相關文章