JavaSE高階程式設計之多執行緒

newknight發表於2022-03-07
Java程式設計執行緒

4. 多執行緒

4.1 基本概念：程式、程式和執行緒

程式、程式和執行緒

程式：為了完成特定的任務，用某種語言編寫的一組指令的集合。程式是一段靜態的程式碼，靜態物件。

程式：是程式的一次執行過程或正在執行的程式。（程式是一個任務）。程式是一個動態的過程：有產生、存在和消亡的過程——即擁有生命週期。

  • 程式是靜態的，程式是動態的
  • 程式作為資源分配的單位，系統在執行時會為每個程式分配不同的記憶體空間

執行緒：程式可進一步細化為執行緒，是一個程式內部的一條執行路徑。一個程式可以包含一個或多個執行緒。

  • 若一個程式同一時間執行多個執行緒，就是支援多執行緒。
  • 執行緒作為執行和排程的單位，每個執行緒擁有獨立的執行棧和程式計數器（pc, program counter register），執行緒切換開銷比較小。
  • 一個程式中的多個執行緒可以共享相同的記憶體單元/記憶體地址空間（它們從同一堆中分配物件，方法區、堆），可以訪問相同的變數和物件。使得執行緒間通訊更高效、便捷。但是多個執行緒操作共享的系統資源可能會帶來安全隱患。

並行與併發

  • 並行：多個CPU同時執行多個任務。
  • 併發：一個CPU（採用時間片）同時執行多個任務。如：秒殺。

多執行緒的優點

  • 提高程式的響應
  • 提高CPU的利用率
  • 改善程式結構

何時需要多執行緒

  • 程式需要同時執行兩個或多個任務
  • 程式需要實現等待的任務
  • 需要後臺執行的程式

多程式和多執行緒比較

和多執行緒相比，多程式缺點：

  • 建立程式比建立執行緒開銷大
  • 程式間通訊比執行緒間通訊慢，因為執行緒間通訊是讀寫同一個變數，速度很快

多程式優點：

  • 多程式穩定性比多執行緒高，以為多程式下，一個程式崩潰不會影響其他程式。而在多執行緒下，任何一個執行緒的崩潰會直接導致整個程式崩潰

Java語言內建了多執行緒支援：一個Java應用程式實際上是一個JVM程式，JVM程式用一個主執行緒執行main()方法，在main()內部，又可以啟動多個執行緒。（一個java.exe，至少有三個執行緒：main()主執行緒，gc()垃圾回收執行緒，異常處理執行緒。）

執行緒的分類

Java執行緒分為兩類：一種是守護執行緒，一種是使用者執行緒。

  • 在各當面幾乎是一樣的，唯一區別是判斷JVM何時離開。
  • 當使用者執行緒執行結束，守護執行緒也會結束。
  • 守護執行緒用來服務使用者執行緒的，在start() 前呼叫 thread.setDaemon(true) 可以把一個使用者執行緒變為守護執行緒
  • Java垃圾回收機制就是一個典型的守護執行緒
  • 若JVM中都是守護執行緒，當前JVM將退出

4.2 執行緒的建立和使用

建立多執行緒有四種方法，這裡有兩種，後續java 1.5增加了兩種新方法。

Java語言的JVM允許程式執行多個執行緒，通過 java.lang.Thread類來體現。

建立一個新執行緒有兩種方法：

第一種：繼承Thread 的方式

將一個類宣告為 Thread 的子類，子類應重寫Thread類的run方法，然後分配並啟動子類的例項。

建立執行緒步驟：

  1. 建立一個繼承於 Thread 類的子類
  2. 重寫 Thread 類的 run() 方法
  3. 建立 Thread 類的子類的物件
  4. 通過物件呼叫 start() 方法

示例：

// 1. 繼承於Thread
class MyThread extends Thread{
    // 2. 重新run方法
    @Override
    public void run() {
        System.out.println("child thread name: "+getName()); // 也可以用 Thread.currentThread().getName()
        // 業務寫在這個方法中
    }
}

public class TheadTest {

    public static void main(String[] args) {
        // 3. 建立物件
        MyThread myThread = new MyThread();
        myThread.setName("子執行緒"); // 設定執行緒名稱
        // 4. 通過物件呼叫 start 方法
        myThread.start();
      
        Thread.currentThread.setName("主執行緒"); // 設定主執行緒名稱
        System.out.println("main thread name: "+Thread.currentThread().getName());

    }
}

輸出結果：
main thread name: 主執行緒
child thread name: 子執行緒

如果要建立多個執行緒

// 如果建立多個子執行緒的話，需要
MyThread myThread = new MyThread();
myThread.start();
MyThread myThread2 = new MyThread();
myThread2.start();
MyThread myThread3 = new MyThread();
myThread3.start();

多個執行緒共享一個靜態變數：

當多個執行緒都想要共用一個值時，比如賣票時的票數，可以將類變數設定為 staitc。

start() 方法的作用

  • 啟動當前執行緒
  • Java虛擬機器呼叫此執行緒的run方法

建立Thread 的匿名子類

簡單一點的話，可以寫Thread 的匿名子類

// 建立Thread 的匿名子類
new Thread(){
    @Override
    public void run() {
        System.out.println("test2");
    }
}.start();

使用Java8引入的 lambda

new Thread(()->{
    System.out.println("t3");
}).start();

執行緒的常用方法

  • start() 啟動當前執行緒；呼叫run方法
  • run() 通常需要重寫Thread類的此方法，將業務寫在此方法中
  • currentThread() 靜態方法，返回執行當前程式碼的執行緒
  • getName() 獲取當前執行緒的名稱
  • setName() 設定當前執行緒的名稱
  • yield() 執行緒讓步，釋放當前CPU的執行權。（暫停當前正在執行的執行緒，給優先順序相同或更高的執行緒讓步）
  • join() 當某個程式執行流中呼叫其他執行緒的join()方法時，呼叫執行緒將被阻塞，直到被呼叫執行緒執行完為止。（線上程a中呼叫執行緒b的join(), 此時執行緒a進入阻塞狀態，直到執行緒b執行完之後，執行緒a才結束阻塞狀態，繼續執行後續程式。）
  • stop() 強制執行緒生命期結束，不推薦
  • sleep(long millis) 使當前正在執行的執行緒以指定的毫秒數暫停（暫時停止執行）
  • isAlive() 判斷當前執行緒是否存活
  • getPriority() 返回此執行緒的優先順序
  • setPriority(int newPriority) 更改執行緒的優先順序

執行緒的排程

排程策略：

  • 時間片
  • 搶佔式：高優先順序的執行緒搶佔CPU

Java的排程方法：

  • 同優先順序執行緒組成先進先出佇列，使用時間片策略
  • 對高優先順序，使用優先排程的搶佔式策略

執行緒的優先順序

  • MAX_PRIORITY: 10 （最高優先順序）
  • MIN_PRIORITY: 1 （最低優先順序）
  • NORM_PRIORITY: 5 （普通優先順序）

執行緒建立時繼承父執行緒的優先順序。

低優先及只是獲得呼叫的概率低，並不意味著只有當高優先順序的執行緒執行完以後才會執行低優先順序。

第二種：實現 Runnable 介面的方式

第二種建立執行緒的方式是：建立一個實現 Runnable 介面的類，類實現了run() 方法，將類的物件傳遞給Thread() 並啟動。

建立執行緒步驟：

  1. 建立一個實現了 Runnable 介面的類
  2. 實現類去實現 Runnable 的抽象方法 run()
  3. 建立實現類的物件
  4. 將物件作為引數傳遞到 Thread 類的構造器中，建立 Thread 類的物件
  5. 通過 Thread 類的物件呼叫 start() 方法

示例：


/**
 * 多執行緒的建立，方式二，實現Runnable介面的方式
 * @author chadJ
 * @create 2022-03-04 18:49
 */

//1. 建立一個實現了 Runnable 介面的類
class MyThread2 implements Runnable{

    //2. 實現類去實現 Runnable 的抽象方法 run()
    @Override
    public void run() {
        System.out.println("t2");
    }
}

public class ThreadRunnable {

    public static void main(String[] args) {
        //3. 建立實現類的物件
        MyThread2 t2 = new MyThread2();
        //4. 將物件作為引數傳遞到 Thread 類的構造器中，建立 Thread 類的物件
        Thread thread = new Thread(t2);
        //5. 通過 Thread 類的物件呼叫 start() 方法
        thread.start();
        
        

        
    }
}

如果要建立多個執行緒

// 如果建立多個子執行緒的話
// t2 物件可以直接使用，也能共享裡面的變數，因為只有一個物件
MyThread2 t2 = new MyThread2();

Thread thread = new Thread(t2);
thread.start();
Thread thread2 = new Thread(t2);
thread2.start();
Thread thread3 = new Thread(t2);
thread3.start();

start()方法如何執行到run

這裡，最後的 start() 方法，是怎麼執行到 MyThread2 中的 run() 方法的呢。原來在

Thread.run中有如下程式碼，如果target 不為空，則執行 target 的run() 方法

  public void run() {
      if (target != null) {
          target.run();
      }
  }

其中，target 是我們呼叫 Thread(t2) 時通過建構函式傳過去的 Runnable

public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}

兩種方式的比對

一種是繼承Thread, 一種是實現Runnable 介面。

開發中，優先選擇：實現 Runnable 介面的方式，

原因：

  • 實現的方式沒有類的單繼承性的侷限性，可以實現了Runnable介面後，實現其他介面
  • 實現的方式更適合來處理多個執行緒有共享資料的情況（實現自然而然能共享資料，繼承得給變數加 static）

聯絡：Thread 也實現的 Runnable。

相同點：兩種方式都需要重寫 run() 方法，將執行緒要執行的邏輯宣告在 run() 中。

第三種：實現 Callable 介面

JDK5.0 新增兩種執行緒建立方式：實現 Callable 介面、使用執行緒池 方式。

與使用 Runnable 相比，Callable 功能更強大：

  • 相比 run() 方法，可以有返回值

  • 方法可以丟擲異常（之前的run()不可以丟擲，因為原方法沒丟擲異常，重寫的不能丟擲）

  • 支援泛型的返回值

  • 需要藉助 FutureTask 類，比如獲取返回結果

    Futrue 介面

    • 可以對具體Runnable Callable 任務的執行結果進行取消、查詢是否完成、獲取結果等操作。
    • FutureTask 是 Future 介面的唯一實現類
    • FutureTask 同時實現了 Runnable 和 Future介面。即可以作為Runnable 被執行緒執行，又可以作為 Future 得到Callable 的返回值。

建立執行緒步驟：

  1. 建立一個實現 Callable 的實現類
  2. 實現 call() 方法，將業務放在call()中。可以有返回值，可以丟擲異常
  3. 建立 Callable 介面實現類的物件
  4. 將此 Callable 實現類的物件作為引數傳遞 FutureTask 構造器中，建立 FutureTask 物件
  5. 將FutureTask 物件作為引數傳遞到 Thread類構造器中（Runnable多型，因為FutureTask實現了Runnable介面），建立 Thread 物件，並呼叫 start()
  6. 可以使用 get() 獲取call() 中的返回值。（ get() 返回值即為 FutureTask 構造器引數 Callable 實現類重寫 call()方法的返回值。）
package com.acfuu.java;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * 建立執行緒方式三：實現Callable介面
 * @author chadJ
 * @create 2022-03-06 14:11
 */

// 1.建立一個實現 Callable 的實現類
class NumThread implements Callable{

    // 2.實現 call() 方法，將業務放在call()中。可以有返回值，可以丟擲異常
    @Override
    public Object call() throws Exception {
        int sum=0;
        for (int i = 0; i <= 100; i++) {
            sum+=i;
        }
        return sum;
    }
}

public class CallableThread {
    public static void main(String[] args) {
        // 3. 建立 Callable 介面實現類的物件
        NumThread numThread = new NumThread();
        // 4. 將此 Callable 實現類的物件作為引數傳遞 FutureTask 構造器中，建立 FutureTask 物件
        FutureTask futureTask = new FutureTask(numThread);
        // 5. 將FutureTask 物件作為引數傳遞到 Thread類構造器中，建立 Thread 物件，並呼叫 start()
        new Thread(futureTask).start();

        try {
            // 6. 可以使用 get() 獲取call() 中的返回值。
            // get() 返回值即為 FutureTask 構造器引數 Callable 實現類重寫 call()方法的返回值。
            Object r = futureTask.get();
            System.out.println("返回值："+r);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

第四種：使用執行緒池（常用）

背景：經常建立和銷燬、使用量特別大的資源，比如併發情況下的執行緒，對效能影響大。

思路：提前建立好多個執行緒，放入執行緒池中，使用時直接獲取，使用完放回池中。可以避免頻繁建立和銷燬，實現重複利用。

好處：

  • 提高響應速度（減少了建立新執行緒的時間）
  • 降低資源消耗（重複利用池中執行緒，不用每次都建立）
  • 便於執行緒管理
    • corePoolSize: 核心池大小
    • maximumPoolSize: 最大執行緒數
    • keepAliveTime: 執行緒沒有任務時的存活時間

執行緒池相關 API

JDK5.0起提供了執行緒池API：ExecutorService 和 Executors

ExexutorService：真正的執行緒池介面。常見子類 ThreadPoolExecutor

  • void execute(Runnable command)：執行任務/命令，沒有返回值，一般用來執行 Runnable
  • <T> Future<T> submit(Callable<T> task)：執行任務，有返回值，一般用來執行 Callable
  • void shutdown()：關閉連線池

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

  • Executors.newCachedThreadPool()：建立一個可根據需要建立新執行緒的執行緒池
  • Executors.newFixedThreadPool()：建立一個可重用固定執行緒池數的執行緒池（常用）
  • Executors.newSingleThreadExecutor()：建立一個只有一個執行緒的執行緒池
  • Executors.newScheduledThreadPool(n)：在給定延遲後建立一個執行緒池

執行緒建立步驟：

  1. 提供指定執行緒數量的執行緒池
  2. 執行指定的執行緒操作，需要提供實現 Runnable 介面或 Callable 介面實現類的物件
  3. 關閉連線池

示例：

package com.acfuu.java;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 建立執行緒方式四：使用執行緒池
 * @author chadJ
 * @create 2022-03-06 14:47
 */


class NumThread2 implements Runnable{

    private boolean odd = true;

    public NumThread2(boolean odd) {
        this.odd = odd;
    }

    @Override
    public void run() {
        for (int i = 0; i <= 10; i++) {
            if(odd){
                if(i%2==1) System.out.println(Thread.currentThread().getName()+"："+i);
            } else{
                if(i%2==0) System.out.println(Thread.currentThread().getName()+"："+i);
            }
        }
    }
}

public class ThreadPool {
    public static void main(String[] args) {
        // 1. 提供指定執行緒數量的執行緒池
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        // 設定執行緒池屬性
        // System.out.println(executorService.getClass());
        // ThreadPoolExecutor executor = (ThreadPoolExecutor) executorService;
        // executor.setCorePoolSize(1); // 設定為1後，執行緒池中就不是10個執行緒，就只有一個執行緒了


        // 2. 執行指定的執行緒操作，需要提供實現 Runnable 介面或 Callable 介面實現類的物件
        executorService.execute(new NumThread2(true)); // 適用於 Runnable
        executorService.execute(new NumThread2(false));
        //executorService.submit(xxx); // 適用於 Callable

        // 3. 關閉連線池
        executorService.shutdown();
    }
}


輸出:
pool-1-thread-1：1
pool-1-thread-2：0
pool-1-thread-2：2
pool-1-thread-2：4
pool-1-thread-2：6
pool-1-thread-2：8
pool-1-thread-2：10
pool-1-thread-1：3
pool-1-thread-1：5
pool-1-thread-1：7
pool-1-thread-1：9

4.3 執行緒的生命週期

JDK 中的Thread.State 類定義了執行緒的狀態。一個執行緒物件只能呼叫一次 start() 方法啟動新執行緒（所以不能一個Thread物件多次start)，並在新執行緒中執行 run() 方法。一旦 run() 執行完畢，執行緒就結束了。

Java 執行緒的狀態有：

  • New, 新建立的執行緒，尚未執行
  • Runnable, 執行中的執行緒，正在執行 run()方法的程式碼
  • Blocked, 執行中的執行緒，因為某些操作被阻塞而掛起
  • Wating, 執行中的執行緒，因為某些操作在等待
  • Time Waiting, 執行中的執行緒，因為執行 sleep() 方法正在計時等待
  • Terminated, 執行緒已終止，run() 執行完畢

執行緒宣告週期：

4.4 執行緒的同步

執行緒的同步是為了解決執行緒的安全問題。

4.4 執行緒的同步

執行緒的同步是為了解決執行緒的安全問題。

問題：比如賣票出現重票、錯票，這就叫出現了執行緒的安全問題。

解決：當一個執行緒a在操作的時候，其他執行緒不能參與進來，直到執行緒a操作結束其他執行緒才可以開始操作。即使執行緒a出現了阻塞，也不能執行其他執行緒。

執行緒的安全問題

在多執行緒模型下，要保證邏輯正確，對共享變數進行讀寫時，必須保證一組指令以原子方式執行：即某一個執行緒執行時，其他執行緒必須等待。通過加鎖和解鎖操作，就能保證指令總是在一個執行緒執行期間，不會有其他執行緒會進入此指令區間。即使在執行期間被作業系統中斷執行，其他執行緒也會因為無法獲得鎖導致無法進入此指令區間。只有釋放後，其他執行緒才有機會獲得鎖並執行。這種加鎖和解鎖之間的程式碼塊我們稱之為臨界區，任何時候臨界區最多隻有一個執行緒能執行。

在Java中，通過同步機制，解決執行緒的安全問題。

同步機制解決執行緒安全問題

使用synchronized （發音 /'sɪŋkrənaɪzd/），有兩種方法：

  • 同步程式碼塊
synchronized(lock) { // lock鎖也叫同步監視器
    // 需要被同步的程式碼。（操作共享資料的程式碼）
}

任何一個類的物件都可以充當鎖。要求：多個執行緒必須共用同一把鎖。



在實現Runnable 介面建立多執行緒的方式中，可以考慮使用 this 充當 lock。

在繼承Thread 類建立多執行緒的方式中，（慎用this充當lock)，考慮使用當前類充當lock。（比如 MyThread.class）

  • 同步方法

    如果操作共享資料的程式碼完整的宣告在一個方法中，我們不妨將此方法宣告同步的。

    需要同步的方法使用 synchronized 修飾：

    1.在實現 Runnable 介面的方式中：

    此種方法中，lock 是 this。

public synchronized void test(){ // 在test中，同步監視器/鎖就是 this
...
}

public void run(){
  ...
  test();
  ...
}

`run()` 方法也可以使用 synchronized修飾， `sysnchronized void run()`，這種要確保 `run()`中使完整的同步資料。不然包裹的太多，效率會低。



2.在繼承 Thread 類的方式中：

為了保證正常執行，需要多加個 static 。

此種方法中，lock 是 當前類。

public static synchronized void test2(){ // 在test2中，同步監視器/鎖就是 當前類
...
}

public void run(){
  ...
  test2();
  ...
}

總結：

- 同步方法仍然涉及到同步監視器，只是不需要我們顯式的宣告
- 非靜態的同步方法，同步監視器是 *this*
- 靜態的同步方法，同步監視器是 *當前類本身*。

執行緒同步優缺點

  • 同步的方式，解決了執行緒的安全問題。
  • 操作同步程式碼時，只能有一個執行緒參與，其他執行緒等待。相當於一個單執行緒的過程，效率低。

只有有共享資料的程式碼才需要使用執行緒的同步解決問題。

Lock 鎖方式解決執行緒安全問題

從JDK 5.0開始，Java提供了更強大的執行緒同步機制——通過顯式定義同步鎖來實現同步。同步鎖使用Lock物件充當。

1.使用ReentrantLock

public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.start();
        t2.start();
        t3.start();
    }
}


class Window implements Runnable{

    private int ticket = 100;

    // 1. 例項化 ReentrantLock
    private final ReentrantLock lock = new ReentrantLock(); // 引數 fair=true/false, 公平或者非公平


    @Override
    public void run() {
        while(true){
            try {

                // 2. 呼叫lock方法
                lock.lock();

                if(ticket>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName()+" 票號："+ticket);
                    ticket--;
                }else{
                    break;
                }
            } finally {
                // 3. 解鎖方法
                lock.unlock();
            }
        }
    }

4.5 執行緒安全的 懶漢式的單例模式

class Bank{
    private Bank(){}

    private static Bank instance = null;

    // 普通獲取例項的方法
    public static Bank getInstance(){
        if(instance==null){
            instance = new Bank();
        }
        return instance;
    }
    
    // 執行緒安全的獲取例項的方法一
    public static synchronized Bank getInstance2(){
        if(instance==null){
            instance = new Bank();
        }
        return instance;
    }

    // 執行緒安全的獲取例項的方法二，其中還有兩種寫法，後一種效率高些
    public static Bank getInstance3(){
        // 效率不高
        /*
        synchronized (Bank.class) {
            if(instance==null){
                instance = new Bank();
            }
            return instance;
        }
         */

        // 效率高一些
        if(instance==null) {
            synchronized (Bank.class) {
                if (instance == null) {
                    instance = new Bank();
                }
            }
        }
        return instance;

    }
}

4.6 執行緒的死鎖問題

死鎖：

  • 不同的執行緒分別佔用對方需要的同步資源，都在等待對方放棄自己需要的同步資源，形成了執行緒的死鎖。
  • 死鎖發生後，沒有任何機制能解除死鎖，只能強制結束JVM程式。

說明：

  • 出現死鎖後，不會異常，不會出現提示，所有執行緒都處於阻塞狀態，無法繼續執行
  • 在使用同步時，要避免出現死鎖

解決方法：

  • 專門的演算法、原則
  • 儘量較少同步資源的定義
  • 儘量避免巢狀同步

示例，下面的程式碼會出現死鎖，程式沒輸出沒結束。在第一個執行緒執行到sleep的時候，執行緒二繼續執行，結果都需要sb1 sb2，產生了死鎖。

    public static void main(String[] args) {
        StringBuffer sb1 = new StringBuffer();
        StringBuffer sb2 = new StringBuffer();

        new Thread(()->{
            synchronized (sb1){
                sb1.append("a");
                sb2.append("1");

                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (sb2){
                    sb1.append("b");
                    sb2.append("2");

                    System.out.println(sb1);
                    System.out.println(sb2);
                }
            }
        }).start();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (sb2){
                    sb1.append("c");
                    sb2.append("3");

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    synchronized (sb1){
                        sb1.append("d");
                        sb2.append("4");

                        System.out.println(sb1);
                        System.out.println(sb2);
                    }
                }
            }
        }).start();
    }

4.7 執行緒的通訊

多執行緒協調（執行緒通訊）問題使用 wait() 和 notify()。

示例：兩個執行緒交替列印1-100

/**
 * 執行緒通訊的示例：兩個執行緒交替列印1-100
 * @author chadJ
 * @create 2022-03-05 22:31
 */


class Number implements Runnable{
    private int number = 1;

    @Override
    public void run() {
        while(true){

            synchronized (this) {

                // 喚醒其他執行緒
                notify();

                if(number<101){
                    System.out.println(Thread.currentThread().getName()+":"+number);
                    number++;

                    try {
                        // 使得呼叫wait()方法的執行緒進入阻塞狀態，並且wait回釋放鎖
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }else{
                    break;
                }
            }

        }
    }
}

public class ThreadCommunication {
    public static void main(String[] args) {
        Number n = new Number();

        Thread t1 = new Thread(n);
        Thread t2 = new Thread(n);

        t1.setName("執行緒1");
        t2.setName("執行緒2");

        t1.start();
        t2.start();

    }
}

執行緒通訊涉及到的方法：

  • wait() 一旦執行此方法，當前執行緒進入阻塞狀態，並釋放同步監視器（鎖）
  • notity() 執行此方法，會喚醒被wait的一個執行緒，如果有多個執行緒被wait，就喚醒優先順序最高的執行緒
  • notifyAll() 執行此方法，會喚醒所有被 wait 的執行緒

說明：

  • 上述三個方法 wait() notify() notifyAll() ，必須使用在同步程式碼塊或同步方法中。Lock想要執行緒通訊使用其他方法
  • wait() notify() notifyAll() 的呼叫者必須使同步程式碼塊或同步方法中的同步監視器，否則會出現 IllegalMonitorStateException。比如
class Test implements Runnable{
  ...
  public void run() {
    synchronized (this) {
        notify();
        ...
        wait();
    }
}
或

class Test implements Runnable{
  ...
  public void run() {
    synchronized (obj) {
        obj.notify();
        ...
        obj.wait();
    }
}
  • 這三個方法是定義在 java.lang.Object 類中的。（從上一條可知，任何一個物件都要能夠呼叫 wait() notify() notifyAll() 方法）

4.8 執行緒通訊應用：生產者消費者問題

描述：生產者將產品交給店員，消費者從店員處取走商品，店員一次能持有產品數量有容量限制，如果生產者試圖生產更多的產品，店員會叫停生產者，如果有空位了再通知生產者繼續生產。如果店中沒有商品，店員會叫停消費者，如果有產品了再通知消費者來取走產品。

分析：

  • 是否是多執行緒問題
  • 是否有共享資料
  • 如何解決執行緒安全問題？同步機制，有三種方法
  • 是否涉及到執行緒通訊
/**
 * 執行緒通訊應用，生產者、消費者問題。 實現Runnable方式
 * @author chadJ
 * @create 2022-03-06 13:13
 */


/**
 * 店員類
 */
class Clerk{
    // 商品數量
    private int goodsNum = 0;

    public synchronized void createProduct() {
        if(goodsNum<20){
            goodsNum++;
            System.out.println(Thread.currentThread().getName()+": 生產商品 "+goodsNum);

            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void useProduce() {
        if(goodsNum>0){

            System.out.println(Thread.currentThread().getName()+": 消費商品 "+goodsNum);
            goodsNum--;

            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Productor implements Runnable{

    private Clerk clerk;

    public Productor(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"：開始生產商品");
        while(true){
            try {
                Thread.sleep(30); // sleep模擬生產過程耗費的時間
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            clerk.createProduct();
        }
    }
}

class Customer implements Runnable{
    private Clerk clerk;

    public Customer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"：開始消費商品");

        while(true){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }


            clerk.useProduce();
        }
    }
}


public class ProductorCustomerTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Thread p1 = new Thread(new Productor(clerk));
        p1.setName("生產者");
        p1.start();

        Thread c1 = new Thread(new Customer(clerk));
        c1.setName("消費者1");
        c1.start();

        Thread c2 = new Thread(new Customer(clerk));
        c2.setName("消費者2");
        c2.start();

        Thread c3 = new Thread(new Customer(clerk));
        c3.setName("消費者3");
        c3.start();
    }
}

4.9 面試題

synchronized 與 Lock 的異同？

相同：二者都可以解決執行緒安全的問題

不同：

  • Lock 是顯式鎖（需要手動啟動和釋放鎖），synchronized 是隱式鎖，出了作用域自動釋放
  • Lock 只有程式碼塊鎖，synchronized 有程式碼塊鎖和方法鎖
  • 使用 Lock 鎖，JVM將花費較少時間來排程執行緒，效能更好

優先使用順序：（建議）

Lock → 同步程式碼塊（已經進入了方法體，分配了相應的資源）→ 同步方法（方法體之外，作用整個方法）

如何解決執行緒安全問題，有幾種方式

同步機制說兩種三種都可以，要都講到

兩種：synchronized方式（又分同步程式碼塊和同步方法）和Lock方式

三種：synchronized 同步程式碼塊、synchronized 同步方法 和 Lock 方式

sleep() 和 wait() 的異同？

相同點：都可以讓執行緒進入阻塞狀態

不同點：

  • 兩個方法宣告的位置不同：Thread 類中宣告的 sleep()；Object 類中宣告的 wait()
  • 呼叫要求不同：sleep() 可以在任何需要的場景下呼叫；wait() 必須使用在同步程式碼塊或同步方法中。
  • 關於是否釋放同步監視器：如果兩方法都使用在同步程式碼塊或同步方法中，sleep()不會釋放鎖，wait() 會釋放鎖。

如何理解實現 Callable 介面的方式建立多執行緒比實現 Runnable 介面建立多執行緒方式更強大？

  • call() 可以有返回值。可以丟擲異常，被捕獲後獲取異常資訊
  • Callable 是支援泛型的

建立多執行緒有幾種方式？

四種：繼承Thread類，實現Runnable介面，實現 Callable 介面，使用執行緒池（後兩種為JDK5.0 新增）。

相關文章