執行緒作為作業系統中最少調度單位，在當前系統的運行環境中，一般都擁有多核處理器，為了更好的充分利用 CPU，掌握其正確使用方式，能更高效的使程式運行，同時，在 Java 面試中，也是極其重要的一個模塊，

執行緒簡介

一個獨立運行的程式是一個行程，一個行程中可以包含一個或多個執行緒，每個執行緒都有屬于自己的一些屬性，如堆疊，計數器等等，同時，一個執行緒在一個時間點上只能運行在一個 CPU 處理器核心上，不同執行緒之間也可以訪問共享變數，執行緒在運行時，系統給每個執行緒分配一些 CPU 時間片，CPU 在時間片這段時間運行某個執行緒，當這個時間片運行完又跳轉至下一段時間片執行緒，CPU 在這些執行緒中進行高速切換，使得程式像是在同時進行多個執行緒操作，

執行緒的實作

實作執行緒常用的兩種方式：繼承 java.lang.Thread 類、實作 java.lang.Runnable 介面，

繼承 Thread 類方式

通過實體化 java.lang.Thread 類獲得執行緒，創建 Thread 物件，一般使用繼承 Thread 類的方式，然后通過方法重寫覆寫 Thread 的某些方法，

首先創建一個繼承 Thread 的子類，

public class DemoThread extends Thread{

    // 重寫 Thread 類中的 run 方法
    @Override
    public void run() {
        // currentThread().getName() 獲取當前執行緒名稱
        System.out.println("java.lang.Thread 創建的"+ currentThread().getName() +"執行緒");
    }
}

上面代碼 DemoThread 實體化的物件就代表一個執行緒，通過重寫 run 方法，在 run 方法中實作該執行緒的邏輯實作，

public class Main {

    public static void main(String[] args) {
        // 實體化 DemoThread 得到新創建的執行緒實體
        DemoThread thread = new DemoThread();
        // 給創建的子執行緒命名
        thread.setName("DemoThread 子執行緒");
        // 啟動執行緒
        thread.start();
        
        // 通過主執行緒列印資訊
        System.out.println("main 執行緒");
    }

}

在程式執行的主執行緒中創建子執行緒，并且命名為DemoThread 子執行緒，在程式的最后列印主執行緒列印的資訊，呼叫執行緒必須呼叫start()方法，在呼叫此方法之前，子執行緒是不存在的，只有start()方法呼叫后，才是真正的創建了執行緒，

執行結果：

從結果可以看到，由于在主執行緒中創建了一個子執行緒，子執行緒相對于主執行緒就相當于是一個異步操作，所以列印結果就有可能main執行緒先于子執行緒執行列印操作，

實作 Runnable 介面方式

由于 Java 是單繼承的特性，所以當創建執行緒的子類繼承了其他的類，就無法實作繼承操作，這時就可以通過實作 Runnable 介面，來實作執行緒創建的邏輯，

首先創建一個實作 Runnable 的類，

public class DemoRunnable implements Runnable {
    
    // 實作 Runnable 中的 run 方法
    @Override
    public void run() {
        System.out.println("java.lang.Runnable 創建的 "+ Thread.currentThread().getName() +"執行緒");
    }
}

Runnable 介面中定義有一個 run 方法，所以實作 Runnable 介面，就必須實作 run 方法，實際上 java.lang.Thread 類也實作了 Runnable 介面，

創建執行緒：

public class Main {

    public static void main(String[] args) {
        // 創建 Thread 實體，并給將要創建的執行緒給命名
        Thread thread = new Thread(new DemoRunnable(), "DemoRunnable 子執行緒");
        // 創建一個執行緒
        thread.start();

        System.out.println("main 執行緒");
    }

}

執行結果

同樣也實作了與繼承 Thread 方式一樣的結果，

創建 Thread 實體時，向新創建的 Thread 實體中傳入了一個實作 Runnable 介面的物件的引數，

Thread 中初始化 Thread#init 的具體實作:

    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals) {
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }

        // 給當前創建的 thread 實體中賦值執行緒名
        this.name = name;
        // 將要創建的執行緒的父執行緒即當前執行緒
        Thread parent = currentThread();
        // 添加到執行緒組操作
        SecurityManager security = System.getSecurityManager();
        if (g == null) {
            if (security != null) {
                g = security.getThreadGroup();
            }

            if (g == null) {
                g = parent.getThreadGroup();
            }
        }
        g.checkAccess();

        if (security != null) {
            if (isCCLOverridden(getClass())) {
                security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
            }
        }
        // 執行緒組中添加為啟動的執行緒數
        g.addUnstarted();
        this.group = g;
        // 設定父執行緒的一些屬性到當前將要創建的執行緒
        this.daemon = parent.isDaemon();
        this.priority = parent.getPriority();
        if (security == null || isCCLOverridden(parent.getClass()))
            this.contextClassLoader = parent.getContextClassLoader();
        else
            this.contextClassLoader = parent.contextClassLoader;
        this.inheritedAccessControlContext =
                acc != null ? acc : AccessController.getContext();
        
        // 將當前傳入 target 的引數，賦值給當前 Thread 物件，使其持有 已實作 Runnable 介面的實體
        this.target = target;
        setPriority(priority);
        if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        
        // 設定執行緒的堆疊大小
        this.stackSize = stackSize;

        // 給創建的執行緒一個 id
        tid = nextThreadID();
    }

上面代碼創建 thread 物件時的 init 方法，通過傳入 Runnable 的實體物件，thread 物件中就持有該物件，

創建 thread 物件后，呼叫 start() 方法，該執行緒就運行持有 Runnable 實作類物件的 run() 方法，

例如本文中案例，就會執行 DemoRunnable#run 方法的邏輯，

這兩種方法創建執行緒的方式，具體使用哪種，根據自身需求選擇，如果需要繼承其他非 Thread 類，就需要使用 Runnable 介面，

執行緒狀態

Java 執行緒每個時間點都存在于6種狀態中一種，

其中 NEW、RUNNABLE、TERMINATED 比較好理解，現在主要針對 BLOCKED、WAITING 和 TIME_WAITING 進行案例講解，

BLOCKED

阻塞狀態 是將兩個執行緒之間處于競爭關系，同時在呼叫 run 時進行加鎖，

首先還是使用上面 Runnable 實作的方式進行改造，

public class DemoRunnable implements Runnable {

    @Override
    public void run() {
        // 通過對DemoRunnable加同步鎖，進行無限回圈不退出
        synchronized (DemoRunnable.class){
            while (true){
                System.out.println("java.lang.Runnable 創建的 "+ Thread.currentThread().getName() +"執行緒");
            }
        }
    }
}

先競爭到 DemoRunnable 類的執行緒進入 run 會一直執行下去，未競爭到的執行緒則會一直處于阻塞狀態，

創建兩個執行緒

public class Main {
    
    public static void main(String[] args) {
        // 創建兩個執行緒測驗
        new Thread(new DemoRunnable(), "test-blocked-1")
                .start();
        new Thread(new DemoRunnable(), "test-blocked-2")
                .start();
    }

}

通過分析執行后的執行緒如圖：

可以得知執行緒test-blocked-1競爭到 DemoRunnable 類，一直都在運行 while 回圈，所以狀態為 RUNNABLE，由于 DemoRunnable#run 中加了同步鎖鎖住 DemoRunnable 類，所以test-blocked-2一直處于 BLOCKED 阻塞狀態，

WAITING

等待狀態 執行緒是不被分配 CPU 時間片，執行緒如果要重新被喚醒，必須顯示被其它執行緒喚醒，否則會一直等待下去，

實作等待狀態例子

public class DemoRunnable implements Runnable {

    @Override
    public void run() {
        while (true){
            // 呼叫 wait 方法，使執行緒在當前實體上處于等待狀態
            synchronized (this){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("java.lang.Runnable 創建的 "+ Thread.currentThread().getName() +"執行緒");
            }
        }
    }
}

// 創建執行緒
public class Main {
    
    public static void main(String[] args) {
        new Thread(new DemoRunnable(), "test-waiting")
                .start();
    }

}

創建該實體執行緒后，分析 test-waiting 執行緒，該執行緒處于 WAITING 狀態，

TIME_WAITING

超時等待狀態 執行緒也是不被分配 CPU 時間片，但是它通過設定的間隔時間后，可以自動喚醒當前執行緒，也就是說，將等待狀態的執行緒加個時間限制就是超時等待狀態，

只需對上面 WAITING 狀態案例增加 wait 時間限制，

public class DemoRunnable implements Runnable {

    @Override
    public void run() {
        while (true){
            synchronized (this){
                try {
                    // 增加等待時長
                    this.wait(1000000, 999999);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("java.lang.Runnable 創建的 "+ Thread.currentThread().getName() +"執行緒");
            }
        }
    }
}

分析執行緒結果，可以看到 test-time_waiting 執行緒處于超時等待狀態，使用 sleep 睡眠時，執行緒也是屬于超時等待狀態，

執行緒狀態之間的轉換，如圖（來源網路）：

Thread 常用方法

currentThread()

currentThread 是獲取當前執行緒實體，回傳 Thread 物件，這是一個靜態方法，使用如下

Thread.currentThread();

start()

start 方法是啟動執行緒的入口方法，這個就是上面實作創建執行緒例子中的 start 方法，

run()

run 方法是執行緒創建后，執行緒會主動呼叫 run 方法執行里面的邏輯，

join()

join 方法即執行緒同步，比如上繼承 Thread 方法實作創建執行緒的例子中，如果在 thread.start() 后呼叫 thread.join() 方法，則 main 執行緒列印的資訊一定在子執行緒列印的資訊之后，這里的 main 執行緒會等待子執行緒執行完后，再繼續執行，

getName()

getName 回傳執行緒名稱，

getId()

獲取執行緒 Id，這是回傳一個 long 型別的 Id 值，

setDaemon()

setDaemon(boolean on) 方法是設定執行緒型別，setDaemon 接受一個 boolean 型別引數，設定為 true 時，執行緒型別為守護執行緒，設定為 false 時，執行緒型別為用戶執行緒，

yield()

yield 方法是執行緒讓步，讓當前執行緒進入就緒狀態，去執行其它相同優先級的執行緒，但不一定會執行其他執行緒，有可能讓步后的執行緒再次被執行，

setPriority()

setPriority(int newPriority) 是設定執行緒執行的優先級，數值為1~10，默認值為5，數值越大執行緒越先執行，

interrupt()

interrupt 方法的作用是中斷執行緒，但是它還是會繼續運行，它只是表示其他執行緒給打了個中斷標志，

interrupted()

interrupted 方法是檢查當前執行緒是否被中斷，呼叫此方法時會清除該執行緒的中斷標志，

isInterrupted()

isInterrupted 方法檢測當前執行緒是否被中斷，如果被中斷了，也不會清除中斷標志，

總結

本文對執行緒的常用功能及概念進行了分析，主要是講解單執行緒的一些操作，執行緒操作的使用在生產中是極容易出現問題的，所以在掌握概念和使用后，需要多研究，多思考應用的設計及實作，在掌握多執行緒操作時，必須對這些的基本使用和概念進行掌握，今后會出進一步對多執行緒分析的文章，

推薦閱讀

《你必須會的 JDK 動態代理和 CGLIB 動態代理》

《Dubbo 擴展點加載機制：從 Java SPI 到 Dubbo SPI》

《volatile 手摸手帶你決議》

標籤：Java

上一篇：WideString和TStrings

下一篇：最流行的 RESTful API 要怎么設計？