1. 使用內核線程（1:1 模型）

2. 使用用戶線程（1:N 模型）

3. 使用用戶線程 + 輕量級進程（LWP）（N:M 模型）

我們先復習下操作系統中的幾個關鍵概念：

• 內核線程 KLT：內核級線程（Kemel-Level Threads, KLT 也有叫做內核支持的線程），直接由操作系統內核支持，線程創建、銷毀、切換開銷較大
• 用戶線程 UT：用戶線程(User Thread,UT)，建立在用戶空間，系統內核不能感知用戶線程的存在，線程創建、銷毀、切換開銷小
• 輕量級進程 LWP：           （LWP，Light weight process）用戶級線程和內核級線程之間的中間層，是由操作系統提供給用戶的操作內核線程的接口的實現 。

• 進程 P：用戶進程 

下面依次介紹三種線程模型：

內核線程模型即完全依賴操作系統內核提供的內核線程（Kernel-Level Thread ，KLT）來實現多線程。在此模型下，線程的切換調度由系統內核完成，系統內核負責將多個線程執行的任務映射到各個CPU中去執行。

程序一般不會直接去使用內核線程，而是去使用內核線程的一種高級接口——輕量級進程（Light Weight Process,LWP），輕量級進程就是我們通常意義上所講的線程，由于每個輕量級進程都由一個內核線程支持，因此只有先支持內核線程，才能有輕量級進程。這種輕量級進程與內核線程之間1:1的關系稱為一對一的線程模型。         

• 用戶線程模型：

  從廣義上來講，一個線程只要不是內核線程，就可以認為是用戶線程（User Thread,UT），因此，從這個定義上來講，輕量級進程也屬于用戶線程，但輕量級進程的實現始終是建立在內核之上的，許多操作都要進行系統調用，效率會受到限制。

  使用用戶線程的優勢在于不需要系統內核支援，劣勢也在于沒有系統內核的支援，所有的線程操作都需要用戶程序自己處理。線程的創建、切換和調度都是需要考慮的問題，而且由于操作系統只把處理器資源分配到進程，那諸如“阻塞如何處理”、“多處理器系統中如何將線程映射到其他處理器上”這類問題解決起來將會異常困難，甚至不可能完成。

  因而使用用戶線程實現的程序一般都比較復雜，此處所講的“復雜”與“程序自己完成線程操作”，并不限制程序中必須編寫了復雜的實現用戶線程的代碼，使用用戶線程的程序，很多都依賴特定的線程庫來完成基本的線程操作，這些復雜性都封裝在線程庫之中，除了以前在不支持多線程的操作系統中（如DOS）的多線程程序與少數有特殊需求的程序外，現在使用用戶線程的程序越來越少了，Java、Ruby等語言都曾經使用過用戶線程，最終又都放棄使用它。

  
           

線程除了依賴內核線程實現和完全由用戶程序自己實現之外，還有一種將內核線程與用戶線程一起使用的實現方式。在這種混合實現下，既存在用戶線程，也存在輕量級進程。

用戶線程還是完全建立在用戶空間中，因此用戶線程的創建、切換、析構等操作依然廉價，并且可以支持大規模的用戶線程并發。而操作系統提供支持的輕量級進程則作為用戶線程和內核線程之間的橋梁，這樣可以使用內核提供的線程調度功能及處理器映射，并且用戶線程的系統調用要通過輕量級線程來完成，大大降低了整個進程被完全阻塞的風險。

在這種混合模式中，用戶線程與輕量級進程的數量比是不定的，即為N：M的關系。許多UNIX系列的操作系統，如Solaris、HP-UX等都提供了N：M的線程模型實現。

對于Sun JDK來說，它的Windows版與Linux版都是使用一對一的線程模型實現的，一條Java線程就映射到一條輕量級進程之中，因為Windows和Linux系統提供的線程模型就是一對一的。在Solaris平臺中，由于操作系統的線程特性可以同時支持一對一（通過Bound Threads或Alternate Libthread實現）及多對多（通過LWP/Thread Based Synchronization實現）的線程模型，因此在Solaris版的JDK中也對應提供了兩個平臺專有的虛擬機參數：-XX：+UseLWPSynchronization（默認值）和-XX：+UseBoundThreads來明確指定虛擬機使用哪種線程模型。

操作系統的線程調度方式           

線程調度是指系統為線程分配處理器使用權的過程。

主要的線程調度方式有兩種，分別是 協同式線程調度（Cooperative Threads-Scheduling）和 搶占式線程調度（Preemptive Threads-Scheduling）

搶占式調度

如果使用搶占式調度的多線程系統，那么每個線程將由系統來分配執行時間，線程的切換不由線程本身來決定（在Java中，Thread.yield（）可以讓出執行時間，但是要獲取執行時間的話，線程本身是沒有什么辦法的）。

在這種實現線程調度的方式下，線程的執行時間是系統可控的，也不會有一個線程導致整個進程阻塞的問題。

Java使用的線程調度方式就是搶占式調度。在JDK后續版本中有可能會提供協程（Coroutines）方式來進行多任務處理。

與前面所說的Windows 3.x的例子相對，在Windows 9x/NT內核中就是使用搶占式來實現多進程的，當一個進程出了問題，我們還可以使用任務管理器把這個進程“殺掉”，而不至于導致系統崩潰。

線程優先級

雖然Java線程調度是系統自動完成的，但是我們還是可以“建議”系統給某些線程多分配一點執行時間，另外的一些線程則可以少分配一點——這項操作可以通過設置線程優先級來完成。

Java語言一共設置了10個級別的線程優先級（Thread.MIN_PRIORITY至Thread.MAX_PRIORITY），在兩個線程同時處于Ready狀態時，優先級越高的線程越容易被系統選擇執行。

不過，線程優先級并不是太靠譜，原因是Java的線程是通過映射到系統的原生線程上來實現的，所以線程調度最終還是取決于操作系統，雖然現在很多操作系統都提供線程優先級的概念，但是并不見得能與Java線程的優先級一一對應。

如Solaris中有2147483648（232）種優先級，但Windows中就只有7種，比Java線程優先級多的系統還好說，中間留下一點空位就可以了，但比Java線程優先級少的系統，就不得不出現幾個優先級相同的情況了。

實現1：繼承Thread類

// 繼承 Threadpublic class MyThread extends Thread {    @Override    public void run() {        System.out.println("MyThread run...");    }}

實現2：實現 Runnable 接口

public class MyRunnable implements Runnable {    @Override    public void run() {        System.out.println("MyRunnable run...");    }}

實現3：實現 Callable 接口，使用 FutureTask 獲取異步返回值

  public static void main(String[] args) throws ExecutionException, InterruptedException {    class MyCallable implements Callable<String> {      @Override      public String call() throws Exception {        return "MyCallable";      }    }    FutureTask<String> task = new FutureTask<>(new MyCallable());    Thread c = new Thread(task);    c.start();    System.out.println(task.get());  }

實現4：JDK8以上版本使用 CompletableFuture 進行異步計算。

在Java8中，提供了非常強大的Future的擴展功能，可以幫助我們簡化異步編程的復雜性，并且提供了函數式編程的能力，可以通過回調的方式處理計算結果，也提供了轉換和組合 CompletableFuture 的方法。

public class CompletableFutureTest {  public static void main(String[] args) {    ExecutorService threadPool = Executors.newFixedThreadPool(2);    // JDK1.8 提供的 CompletableFuture    CompletableFuture<String> futureTask = CompletableFuture.supplyAsync(new Supplier<String>() {      @Override      public String get() {        System.out.println("task start");        try {          Thread.sleep(10000);        } catch (Exception e) {          e.printStackTrace();          return "execute failure";        }        System.out.println("task end");        return "execute success";      }    }, threadPool);    // 異步獲取 futureTask 的執行結果，此處代碼可以跟其他流程代碼放在一起    futureTask.thenAccept(e-> System.out.println("future task result:" + e));    System.out.println("main thread end");  }}
輸出結果：task startmain thread endtask endfuture task result:execute success

實現5：使用線程池，ThreadPoolExecutor 類。

public ThreadPoolExecutor(int corePoolSize,                          int maximumPoolSize,                          long keepAliveTime,                          TimeUnit unit,                          BlockingQueue<Runnable> workQueue,                          ThreadFactory threadFactory) {        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, defaultHandler);}<T> Future<T> submit(Callable<T> task);Future<?> submit(Runnable task);