摘要：多線程一線程模型實現線程有三種方式使用內核線程實現使用用戶線程實現和使用用戶線程加輕量級進程混合實現。這種輕量級進程與內核線程之間的關系稱為一對一的線程模型。是通知所有等待對象控制權的線程繼續運行。

實現線程有三種方式：使用內核線程實現、使用用戶線程實現和使用用戶線程加輕量級進程混合實現。內核線程是直接由操作系統內核支持的線程，通過內核完成線程切換，內核通過操縱調度器對線程進行調度，并負責將線程的任務映射到各個處理器上。
程序不會直接使用內核線程，而是去使用內核線程的高級接口-輕量級進程。每個輕量級進程由一個內核線程支持。這種輕量級進程與內核線程之間1：1的關系稱為一對一的線程模型。Sun JDK 的Windows版和Linux版都是使用一對一的線程模型，一條Java線程就映射到一條輕量級進程中。由于內核線程的支持，每個輕量級進程成為一個獨立的調度單元，一個輕量級進程的阻塞不會影響整個進程。但也是因為基于內核線程實現，各種線程操作，如創建、析構及同步都要進行系統調用，需要在用戶態和內核態中來回切換，調用代價高，其次輕量級進程消耗一定的內核資源，因此一個系統支持輕量級進程的數量有限。

線程調度是指系統為線程分配處理器使用權的過程，分為協同式調度和搶占式調度。協同式調度的多線程系統，線程執行時間由線程本身控制，線程完成自己的工作之后，主動通知系統切換到另一個線程上。優點是實現簡單，切換操作是由線程主動的，對線程可知，沒有線程同步問題。缺點是線程執行時間不可控制，如果一個線程阻塞，可能導致整個系統奔潰。搶占式調度的多線程系統，每個線程有系統分配執行時間，線程的切換不由線程本身決定。（yield可以讓出執行時間，但線程本身無法獲取執行時間）優點是線程執行時間系統可控。Java使用的線程調度方式就是搶占式調度。

Java線程的6種狀態：

New（新建）

Runnable（可運行）

Blocked（阻塞）

Waiting（等待）

Timed waiting（限時等待）

Terminated（終止）

線程創建成功但尚未啟動就是New；Runable狀態的線程可能正在執行，也可能在等待CPU分配執行時間；當線程等待另一個線程通知調度器一個條件時就進入等待狀態，例如Object.wait、Thread.join;當這些方法指定時間參數時就成了限時等待；當一個線程試圖獲取一個內部的對象鎖，而該鎖被另一線程持有時，該線程進入阻塞狀態；當線程因run方法正常退出而自然死亡，或者因為沒有捕獲的異常死亡都會導致線程進入Terminated狀態。

Java中斷機制是一種協作機制，通過中斷并不能直接終止另一個線程，而需要被中斷的線程自己處理中斷。當對一個線程調用interrup方法時，線程的中斷狀態將被置位。這是每一個線程都具有的boolean標志位。每個線程都應該不時地檢查這個標志，以判斷線程是否被中斷，并及時處理。

public void interrupt() {
    if (this != Thread.currentThread())
        checkAccess();

    synchronized (blockerLock) {
        Interruptible b = blocker;
        if (b != null) {
            interrupt0();           // Just to set the interrupt flag
            b.interrupt(this);
            return;
        }
    }
    interrupt0();
}

public static boolean interrupted() {
    return currentThread().isInterrupted(true);
}
public boolean isInterrupted() {
    return isInterrupted(false);
}
private native boolean isInterrupted(boolean ClearInterrupted);

可以看到，interrupt方法通過設置中斷位來完成中斷。interrupted方法和isInterrupted方法都是通過調用native方法來檢測中斷的，interrupted是一個靜態方法，用來檢測當前線程是否被中斷，而且interrupted會清除該線程的中斷狀態；isInterrupted是一個實例方法，可用來檢驗是否有線程被中斷，該方法不會改變中斷狀態。

一般來說，我們中斷線程的目的很可能是想停止線程執行。怎么停止線程執行呢？我們可以在判斷中斷置位后，用return退出run方法。但這樣設計并不優雅，另外一種方式，就是拋出InterruptedException并在run方法里捕獲。捕獲后怎么處理也是件值得考慮的事，最好的方法是直接拋給調用者處理，但run方法是重寫方法，結構已固定，無法拋出異常，我們還可以在捕獲InterruptedException后重新中斷當前線程，讓調用者檢測。

wait方法是掛起當前線程，釋放當前對象的控制權（釋放鎖），然后線程處于等待狀態。notify是通知正在等待對象控制權（鎖）的線程可以繼續運行。notifyAll是通知所有等待對象控制權的線程繼續運行。這幾個方法是基于monitor監視器鎖來實現的，所以必須在同步塊內執行。

sleep讓當前線程暫停指定時間。wait方法依賴于同步，sleep可以直接調用。因為sleep只是暫時讓出CPU的執行權，并不釋放鎖，而wait需要釋放鎖。舉個簡單的例子：

public class WaitTest {
    private static Object o = new Object();
    
    static class Thread1 extends Thread{

        @Override
        public void run() {
            try {
                synchronized(o){
                    System.out.println("Thread1--start");
                    //o.wait();
                    Thread.sleep(2000);
                    System.out.println("Thread1--end");
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("a");
            }
        }
    }
    
    static class Thread2 extends Thread{

        @Override
        public void run() {
            synchronized(o){
                System.out.println("Thread2--start");
                o.notify();
                System.out.println("Thread2--end");
            }
        }
    }
    
    public static void main(String[] args) throws InterruptedException{
        Thread1 t1 = new Thread1();
        Thread2 t2 = new Thread2();
        t1.start();
        Thread.sleep(100);//保證t1先獲得鎖
        t2.start();
    }
}

在線程1里分別調用sleep和wait會有不同的結果，調用sleep時線程1不會釋放鎖，所以會打印完“Thread1 start”、“Thread1 end”，再進入線程2的打印。調用wait時，打印完“Thread1-start”，就會釋放鎖，這時線程2的打印得以繼續進行，會打印“Thread2 start”。

Thread.yield()方法會將當前線程從Running轉為Runnable，讓出當前對進程的使用，以便其他線程有機會執行，不過調度器可以忽虐該方法，也不能指定暫停時間，一般只用來調試和測試。

Thread.join()方法用于將異步的線程“合并”為同步的線程，父線程等待子線程執行完成后再執行。其實并不算合并，而是調用join的線程進入限時等待，不斷檢查子線程狀態，在子線程執行完成后恢復執行。看一下它的實現原理：

public final synchronized void join(long millis)
throws InterruptedException {
    long base = System.currentTimeMillis();
    long now = 0;

    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (millis == 0) {
        while (isAlive()) {
            wait(0);
        }
    } else {
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay);
            now = System.currentTimeMillis() - base;
        }
    }
}

可以看到，join是通過子線程不斷輪詢自己狀態一直到執行完畢才返回繼續執行父線程。

在Java中，最基本的互斥同步手段就是synchronized關鍵字，synchronized自動提供一個鎖以及相關的條件。synchronized同步塊對于同一條線程來說是可重入的，其次，同步塊在已進入的線程執行完之前，會阻塞后面其他線程的進入。前面提到，Java的線程是映射到系統原生線程上，阻塞或喚醒一個線程，都需要操作系統幫忙完成，需要從用戶態轉為核心態，這需要耗費很長時間。因此synchronized是重量級操作，虛擬機本身會有一些優化手段，比如在阻塞之前加入自旋等待過程，避免頻繁切入核心態之中。

重入鎖（ReentrantLock）與synchronized相似，具備一樣的線程重入性，一個表現為API層面的互斥鎖，另一個表現為原生語法層面的互斥鎖。ReetrantLock增加了一些功能：等待可中斷、公平鎖和鎖綁定多個條件。

公平鎖是指多個線程等待同一個鎖時，必須按照申請鎖的時間順序來依次獲得鎖，可以通過帶布爾值的構造函數要求使用公平鎖。

 /**
     * Creates an instance of {@code ReentrantLock} with the
     * given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

等待可中斷是指持有鎖的線程長期不釋放鎖的時候，正在等待的線程可以選擇放棄等待：

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockTestOne {
    static int count = 0;
    static ReentrantLock lock = new ReentrantLock();
    
    public static void main(String[] args) throws Exception{
        Thread a = new Thread(new CountThread("a"));
        Thread b = new Thread(new CountThread("b"));
        a.start();
        Thread.sleep(100);//確保b線程后執行，a能先獲得鎖
        b.start();
        Thread.sleep(500);//等待0.5s后，a線程還沒有釋放鎖，通過中斷放棄等待
        b.interrupt();
    }
    
    static class CountThread extends Thread{
        
        String name;

        CountThread(String name){
            this.name = name;
        }
                
        @Override
        public void run() {
            /*try{
                lock.lockInterruptibly();
            }catch(InterruptedException e){
                System.out.println("Thread "+name+" interrupted");
                return;
            }*/
            lock.lock();
            System.out.println(Thread.currentThread().isInterrupted());
            try{
                System.out.println("Thread "+name+" begin");
                for(int i=0; i<2000000; i++){
                    for(int j=0; j<100000; j++){
                        count++;
                    }
                }
                System.out.println("Thread "+name+" end");
            }finally{
                lock.unlock();
            }
        }
    }
}

我們先看lock.lock的執行結果：

可以看見a線程執行完后b才開始執行，且b線程的中斷位已被置位。說明lock是阻塞式的獲取鎖，只有在成功獲取到鎖以后才處理中斷信息，并且怎么處理由調用端決定，lock只負責給中斷位置位。
再看一下lock.lockInterruptibly的執行結果：

可以看到，lockInterruptibly會立即處理中斷信息，拋出InterruptedException，而不用等到獲取鎖。

鎖綁定多個條件是指一個ReentrantLock對象可以同時綁定多個Condition對象。在synchronized中，鎖對象的wait和notify其實實現一個隱含的條件，如果要和多個條件關聯，必須額外添加鎖。

public class ReentrantLockTestTwo {
    
    static ReentrantLock lock = new ReentrantLock();
    
    static Condition productCondition = lock.newCondition();
    static Condition customerCondition = lock.newCondition();
    
    static Set