大家好，我是線程，我的英文名叫 Thread，別看我現在風光無限，好像人盡皆知的樣子，然而我的身世卻悲慘離奇。

我出身在一個小山村，那是一個與世隔絕的世外桃源，然而年紀輕輕的我，卻展現出了與眾不同的性格。比如：當身邊的同齡人還在沉浸于玩泥巴的喜悅時，我就開始思考如何避免下雨天對出行造成的阻礙?當身邊的同齡人還在沉浸于夕陽下的奔跑時，我已經開始思考為什么太陽會東升西落?而我們人類又為什么會生存在地球上?于此可見一斑。

當時的我在所有人眼里就是一個“怪人”，村里面的阿貓、阿狗走路都要躲著我。但我的母親懂我，她知道這個小伙子器宇不凡、骨骼驚奇，必是練武奇才，將來保護宇宙的重任和維護世界和平的重任可能要交付與我這個神童身上了，于是在我剛滿 3 歲那天，母親就把我過繼給了她的一位遠房親戚了。

首位母親：繼承Thread

接下來我要把我的出生過程演示給你看，這也是我的第一段人生經歷。

創建方式一

線程最原始的創建方式，只需要繼承 Thread 類，重寫 run() 方法即可，實現代碼如下：

// 創建方式 1：繼承 Thread 
class MyThread extends Thread { 
    @Override 
    public void run() { 
        System.out.println("你好，線程~"); 
    } 
} 
// 測試 
public class ThreadExample { 
    public static void main(String[] args) { 
        // 創建線程 
        Thread thread = new MyThread(); 
        // 啟動線程 
        thread.start(); 
    } 
} 

變種方法

以上創建線程的方式略顯繁瑣，我們也可以使用匿名對象的方式，在創建 Thread 類的時候就直接重寫 run() 方法，實現代碼如下：

// 變種 1：匿名方式創建線程 
Thread t1 = new Thread() { 
    @Override 
    public void run() { 
        System.out.println("線程變種"); 
    } 
}; 
// 啟動線程 
t1.start(); 

繼承Thread的缺點

Java 語言的設計是單繼承，所以當繼承了 Thread 之后，就不能再繼承其他類了。

也就是說，如果我一直呆在親生母親(extends Thread)的身邊，那么就得不到好的教育，所以長大之后也注定會普普通通，這可能就是母親把我過繼給遠房親戚的原因吧。

第二位母親：實現Runnable

在 Java 語言中，雖然不能實現多繼承，但可以實現多接口，所以我在第二位母親家，過得也算如魚得水。

創建方式二

和繼承 Thread 類差不多，實現 Runnable 接口也是重寫 run() 方法，具體實現代碼如下：

public class ThreadExample2 { 
    // 創建方式 2：實現 Runnable 接口 
    static class MyThread implements Runnable { 
        @Override 
        public void run() { 
            System.out.println("你好，線程~"); 
        } 
    } 
    // 代碼測試 
    public static void main(String[] args) { 
        // 創建 Runnable 子類 
        MyThread myThread = new MyThread(); 
        // 創建線程 
        Thread thread = new Thread(myThread); 
        // 啟動線程 
        thread.start(); 
    } 
} 

變種方法1：匿名Runnable

以上實現 Runnable 的接口有更簡單的實現方法，我們可以使用匿名 Runnable 來創建一個線程，如下代碼所示：

// 變種 1：匿名 Runnable 方式 
Thread t2 = new Thread(new Runnable() { 
    @Override 
    public void run() { 
        System.out.println("我是線程變種方法~"); 
    } 
}); 
// 啟動線程 
t2.start(); 

變種方法2：Lambda創建Runnable

在 JDK 8 之后，我們可以使用 Lambda 表達式來操作代碼了，所以對于創建匿名 Runnable 類，我們也有了更簡單的實現方法，如下代碼所示：

// 變種 2：使用 Lambda 匿名 Runnable 方式 
Thread t3 = new Thread(() -> { 
    System.out.println("我是變種 2~"); 
}); 
// 啟動線程 
t3.start(); 

注意：以上實現代碼只支持 JDK 1.8+ 版本。

第三位母親：村里的首富

雖然我的前兩位母親對我都很好，但對于我這樣一個氣宇軒揚、骨骼驚奇將來要拯救宇宙和維護世界和平的少年來說，只在國內混未免局限性太大，所以我一直想去大洋彼岸追尋自己的夢想，然而以「前兩位」母親的財力不足以支撐我這樣做。

然而我的第二個家庭和村里的首富一家是至交，得知我的志向之后，他們一家愿意傾囊相授，舉一家之力幫我去大洋彼岸追尋我的夢想。于是在感激之余，我的第二位母親讓我當場認下首富一家為我的干爹、干媽。就這樣，我就有了第三位母親了。

創建方式三

前兩種創建方式雖然不錯，但都不能接收線程執行之后的返回值，于是在 JDK 1.5 之后就加入了 Callable 和 Futrue，用于接收線程執行之后的返回值，具體的實現代碼如下：

import java.util.Random; 
import java.util.concurrent.Callable; 
import java.util.concurrent.ExecutionException; 
import java.util.concurrent.FutureTask; 
 
/** 
 * 線程創建示例 3 
 */ 
public class CreateThreadExample3 { 
    // 創建方式 3：實現 Callable 接口 
    static class MyCallable implements Callable<Integer> { 
 
        @Override 
        public Integer call() throws Exception { 
            int num = new Random().nextInt(10); 
            System.out.println("生成隨機數：" + num); 
            return num; 
        } 
    } 
    // 代碼測試 
    public static void main(String[] args) throws ExecutionException, InterruptedException { 
        // 創建 Callable 子對象 
        MyCallable callable = new MyCallable(); 
        // 使用 FutureTask 配合 Callable 子對象得到執行結果 
        FutureTask<Integer> futureTask = new FutureTask<>(callable); 
        // 創建線程 
        Thread thread = new Thread(futureTask); 
        // 啟動線程 
        thread.start(); 
        // 得到線程執行的結果 
        int result = futureTask.get(); 
        System.out.println("主線程中拿到子線程執行結果：" + result); 
    } 
} 

以上代碼的執行結果如下：

從以上結果可以看出，使用 Callable 配合 FutrueTask 可以正確拿到線程執行之后的返回值。而我的故事也在這里結束了，我最終不負三位母親所望，雖不能拯救宇宙和維護世界和平，但卻也能在程序界作出自己的一些貢獻，這就是我和我三位母親的故事。

總結

本文使用第一人稱“我”(Thread)的視角講了線程創建的三種方式，第一種是繼承 Thread，但因為 Java 語言不允許多繼承，所以當繼承了 Thread 之后就不能繼承其他類了，于是就有了第二種方式實現 Runnable 接口的方式。然而前兩種實現雖然可以創建線程，但不能接收線程執行之后的返回值，于是就有了第三種實現 Callable，通過它我們可以取得線程執行之后的返回值。