by emanjusaka from  https://www.emanjusaka.top/archives/7 彼岸花開可奈何
本文歡迎分享與聚合，全文轉載請留下原文地址。

前言

在並行程式設計中我們為啥一般選用建立多個執行緒去處理任務而不是建立多個程序呢？這是因為執行緒之間切換的開銷小，適用於一些要求同時進行並且又要共用某些變數的並行操作。而程序則具有獨立的虛擬地址空間，每個程序都有自己獨立的程式碼和資料空間，程式之間的切換會有較大的開銷。下面介紹幾種建立執行緒的方法，在這之前我們還是要先了解一下什麼是程序什麼是執行緒。

一、什麼是程序和執行緒

執行緒是程序中的一個實體，它本身是不會獨立存在的。程序是系統進行資源分配和排程的基本單位，執行緒則是程序的一個執行路徑，一個程序中至少有一個執行緒，程序中的多個執行緒共用程序的資源。

程序和執行緒的關係圖如下：

從上面的圖中，我們可以知道一個程序中有多個執行緒，多個執行緒共用程序的堆和方法區資源，但是每個執行緒都有自己的程式計數器和棧區域。堆是一個程序中最大的一塊記憶體，堆是被程序中的所有執行緒共用的，是程序建立時分配的，堆裡面主要存放使用new操作建立的物件範例。方法區則用來存放 JVM 載入的類、常數及靜態變數等資訊，也是執行緒共用的。

二、執行緒的建立

Java 中有幾種執行緒建立的方式：

實現 Runnable 介面的 run 方法
繼承 Thread 類並重寫 run 的方法
使用 FutureTask 方式
使用執行緒池建立

2.1、實現 Runnable 介面的 run 方法

public static void main(String[] args) {
        RunableTask task = new RunableTask();
        new Thread(task).start();
        new Thread(task).start();
    }

    public static class RunableTask implements Runnable {
        @Override
        public void run() {
            System.out.println("I am a child thread");
        }
    }
// 輸出
I am a child thread
I am a child thread

這段程式碼建立了一個RunableTask類，該類實現了Runnable介面，並重寫了run()方法。在run()方法中，它列印了一條訊息："I am a child thread"。

接下來是main()方法，它是Java程式的入口點。在main()方法中，首先建立了一個RunableTask物件，然後通過呼叫Thread類別建構函式將該物件作為引數傳遞給Thread類別建構函式，建立了兩個新的執行緒物件。這兩個執行緒物件分別使用start()方法啟動，從而使得每個執行緒都能夠並行地執行。

當程式執行時，會建立兩個子執行緒，它們將並行地執行RunableTask物件的run()方法。由於兩個執行緒是同時執行的，因此它們可能會交替執行run()方法中的程式碼。在這種情況下，由於執行緒排程的不確定性，可能會出現以下情況之一：

第一個執行緒先執行run()方法，列印出"I am a child thread"。
第二個執行緒先執行run()方法，列印出"I am a child thread"。

需要注意的是，由於執行緒的執行順序是不確定的，所以每次執行程式時，輸出的結果可能會有所不同。

2.2、繼承 Thread 類方式的實現

public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }

    //繼承Thread類並重寫run方法
    public static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("I am a child thread");
        }
    }

建立一個名為MyThread的類，該類繼承了Thread類，並重寫了run()方法。

2.3、用 FutureTask 的方式

 public static void main(String[] args) throws InterruptedException {
        // 建立非同步任務
        FutureTask<String> futureTask = new FutureTask<>(new CallerTask());
        //啟動執行緒
        new Thread(futureTask).start();
        try {
            //等待任務執行完畢，並返回結果
            String result = futureTask.get();
            System.out.println(result);
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

    //建立任務類，類似Runable
    public static class CallerTask implements Callable<String> {
        @Override
        public String call() throws Exception {
            return "hello emanjusaka";
        }
    }

上面使用了FutureTask和Callable介面來實現非同步任務的執行。首先，在main()方法中建立了一個FutureTask物件，並將一個匿名內部類CallerTask的範例作為引數傳遞給它。這個匿名內部類實現了Callable介面，並重寫了call()方法。在call()方法中，它返回了一個字串"hello emanjusaka"。接下來，通過呼叫FutureTask物件的start()方法啟動了一個新的執行緒，該執行緒會執行CallerTask物件的call()方法。由於start()方法是非同步執行的，主執行緒會繼續執行後續的程式碼。然後，使用futureTask.get()方法來等待非同步任務的執行結果。這個方法會阻塞當前執行緒，直到非同步任務執行完畢並返回結果。如果任務執行過程中發生了異常，可以通過捕獲ExecutionException來處理異常情況。

需要注意的是，由於非同步任務的執行是並行進行的，因此輸出的結果可能會有所不同。另外，由於FutureTask和Callable介面提供了更靈活和強大的功能，因此在需要處理返回結果或處理異常的情況下，它們比繼承Thread類並重寫run()方法的方式更加方便和可靠。

2.4、使用執行緒池

Executors

package top.emanjusaka;

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

public class Main {
    public static void main(String[] args) {
        // 建立一個固定大小的執行緒池，大小為5
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // 提交10個任務到執行緒池中執行
        for (int i = 0; i < 10; i++) {
            Runnable worker = new WorkerThread("" + i);
            executor.execute(worker);
        }

        // 關閉執行緒池
        executor.shutdown();
        while (!executor.isTerminated()) {
        }

        System.out.println("所有任務已完成");
    }
}

class WorkerThread implements Runnable {
    private String command;

    public WorkerThread(String s) {
        this.command = s;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 開始處理任務： " + command);
        processCommand();
        System.out.println(Thread.currentThread().getName() + " 完成任務： " + command);
    }

    private void processCommand() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
// 輸出
pool-1-thread-1 開始處理任務： 0
pool-1-thread-2 開始處理任務： 1
pool-1-thread-3 開始處理任務： 2
pool-1-thread-4 開始處理任務： 3
pool-1-thread-5 開始處理任務： 4
pool-1-thread-2 完成任務： 1
pool-1-thread-4 完成任務： 3
pool-1-thread-2 開始處理任務： 5
pool-1-thread-4 開始處理任務： 6
pool-1-thread-1 完成任務： 0
pool-1-thread-3 完成任務： 2
pool-1-thread-5 完成任務： 4
pool-1-thread-3 開始處理任務： 8
pool-1-thread-1 開始處理任務： 7
pool-1-thread-5 開始處理任務： 9
pool-1-thread-2 完成任務： 5
pool-1-thread-4 完成任務： 6
pool-1-thread-1 完成任務： 7
pool-1-thread-3 完成任務： 8
pool-1-thread-5 完成任務： 9
所有任務已完成

上面的例子中我們首先建立了一個大小為5的執行緒池。然後，我們提交了10個任務到執行緒池中執行。每個任務都是一個實現了Runnable介面的WorkerThread物件。最後，我們關閉執行緒池並等待所有任務完成。

阿里巴巴開發規範建議使用ThreadPoolExecutor來建立執行緒池，而不是直接使用Executors。這樣做的原因是，Executors建立的執行緒池可能會存在資源耗盡的風險，而ThreadPoolExecutor則可以更好地控制執行緒池的執行規則，規避資源耗盡的風險。

ThreadPoolExecutor

package top.emanjusaka;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) {
        // 建立一個固定大小的執行緒池，大小為5
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());

        for (int i = 0; i < 10; i++) {
            Runnable worker = new WorkerThread("" + i);
            executor.execute(worker);
        }

        // 關閉執行緒池
        executor.shutdown();
        try {
            executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("所有任務已完成");
    }
}

class WorkerThread implements Runnable {
    private String command;

    public WorkerThread(String s) {
        this.command = s;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 開始處理任務：" + command);
        processCommand();
        System.out.println(Thread.currentThread().getName() + " 完成任務：" + command);
    }

    private void processCommand() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

// 輸出
pool-1-thread-1 開始處理任務：0
pool-1-thread-3 開始處理任務：2
pool-1-thread-2 開始處理任務：1
pool-1-thread-4 開始處理任務：3
pool-1-thread-5 開始處理任務：4
pool-1-thread-2 完成任務：1
pool-1-thread-3 完成任務：2
pool-1-thread-5 完成任務：4
pool-1-thread-3 開始處理任務：5
pool-1-thread-4 完成任務：3
pool-1-thread-1 完成任務：0
pool-1-thread-4 開始處理任務：8
pool-1-thread-2 開始處理任務：7
pool-1-thread-5 開始處理任務：6
pool-1-thread-1 開始處理任務：9
pool-1-thread-4 完成任務：8
pool-1-thread-3 完成任務：5
pool-1-thread-2 完成任務：7
pool-1-thread-1 完成任務：9
pool-1-thread-5 完成任務：6
所有任務已完成

在這個例子中，我們首先建立了一個大小為5的執行緒池，其中核心執行緒數為5，最大執行緒數為10，空閒執行緒存活時間為200毫秒，工作佇列為LinkedBlockingQueue。然後，我們提交了10個任務到執行緒池中執行。最後，我們關閉執行緒池並等待所有任務完成。

ThreadPoolExecutor的建構函式有以下引數：

corePoolSize：核心執行緒數，即執行緒池中始終保持活躍的執行緒數。
maximumPoolSize：最大執行緒數，即執行緒池中允許的最大執行緒數。當工作佇列滿了之後，執行緒池會建立新的執行緒來處理任務，直到達到最大執行緒數。
keepAliveTime：空閒執行緒存活時間，即當執行緒池中的執行緒數量超過核心執行緒數時，多餘的空閒執行緒在等待新任務的最長時間。超過這個時間後，空閒執行緒將被銷燬。
unit：keepAliveTime的時間單位，例如TimeUnit.SECONDS表示秒，TimeUnit.MILLISECONDS表示毫秒。
workQueue：工作佇列，用於存放待處理的任務。常用的有ArrayBlockingQueue、LinkedBlockingQueue和SynchronousQueue等。
threadFactory：執行緒工廠，用於建立新的執行緒。可以自定義執行緒的名稱、優先順序等屬性。
handler：拒絕策略，當工作佇列滿了且執行緒池已滿時，執行緒池如何處理新提交的任務。常用的有AbortPolicy（丟擲異常）、DiscardPolicy（丟棄任務）和DiscardOldestPolicy（丟棄佇列中最舊的任務）。
executorListeners：監聽器，用於監聽執行緒池的狀態變化。常用的有ThreadPoolExecutor.AbortPolicy、ThreadPoolExecutor.CallerRunsPolicy和ThreadPoolExecutor.DiscardPolicy。

三、總結

使用繼承方式的好處是方便傳參，你可以在子類裡面新增成員變數，通過set方法設定引數或者通過建構函式進行傳遞，而如果使用Runnable方式，則只能使用主執行緒裡面被宣告為final的變數。不好的地方是Java不支援多繼承，如果繼承了Thread類，那麼子類不能再繼承其他類，而Runable則沒有這個限制。前兩種方式都沒辦法拿到任務的返回結果，但是Futuretask方式可以。

使用Callable和Future建立執行緒。這種方式可以將執行緒作為任務提交給執行緒池執行，而且可以獲取到執行緒的執行結果。但是需要注意的是，如果執行緒丟擲了異常，那麼在主執行緒中是無法獲取到的。使用執行緒池。執行緒池是一種管理執行緒的機制，可以有效地控制執行緒的數量和複用執行緒，避免了頻繁地建立和銷燬執行緒帶來的效能開銷。

參考資料

《Java並行程式設計之美》

本文原創，才疏學淺，如有紕漏，歡迎指正。尊貴的朋友，如果本文對您有所幫助，歡迎點贊，並期待您的反饋，以便於不斷優化。

原文地址： https://www.emanjusaka.top/archives/7

微信公眾號：emanjusaka的程式設計棧

探索 Java 執行緒的建立

前言