金三銀四源葫，很多小伙伴都打算跳槽诗越。而多線程是面試必問的，給大家分享下 Thread 源碼解析息堂，也算是我自己的筆記整理嚷狞、思維復(fù)盤。學(xué)習(xí)的同時(shí)荣堰，順便留下點(diǎn)什么~

1床未、設(shè)置線程名

在使用多線程的時(shí)候，想要查看線程名是很簡單的振坚，調(diào)用 Thread.currentThread().getName() 即可薇搁。默認(rèn)情況下，主線程名是 main渡八，其他線程名是 Thread-x啃洋，x 代表第幾個(gè)線程传货。

我們點(diǎn)進(jìn)去構(gòu)造方法，看看它是怎么命名的：調(diào)用了 init 方法宏娄，init 方法內(nèi)部調(diào)用了 nextThreadNum 方法问裕。

public Thread() {
    init(null, null, "Thread-" + nextThreadNum(), 0);
}

nextThreadNum 是一個(gè)線程安全的方法，同一時(shí)間只可能有一個(gè)線程修改孵坚，而 threadInitNumber 是一個(gè)靜態(tài)變量僻澎，它可以被類的所有對象訪問。所以十饥，每個(gè)線程在創(chuàng)建時(shí)直接 +1 作為子線程后綴。

/* For autonumbering anonymous threads. */
private static int threadInitNumber;
private static synchronized int nextThreadNum() {
    return threadInitNumber++;
}

再看 init 方法祖乳，注意到最后有 this.name = name 賦值給 volatile 變量的 name逗堵，默認(rèn)就是用 Thread-x 作為子線程名。

private void init(ThreadGroup g, Runnable target, String name,long stackSize) {
    init(g, target, name, stackSize, null, true);
}


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");
    }
    // 名稱賦值
    this.name = name;
    // 省略代碼
}

最終 getName 方法拿到的就是這個(gè) volatile 變量 name 的值眷昆。

private volatile String name;

public final String getName() {
    return name;
}

注意到源碼中蜒秤，有帶 name 參數(shù)的構(gòu)造方法：

public Thread(Runnable target, String name) {
    init(null, target, name, 0);
}

所以，我們可以初始化時(shí)就指定線程名

public class MyThread implements Runnable {

    @Override
    public void run() {
        // 打印當(dāng)前線程的名字
        System.out.println(Thread.currentThread().getName());
    }
}

public class TestMain {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();

        //帶參構(gòu)造方法給線程起名字
        Thread thread1 = new Thread(myThread, "一個(gè)優(yōu)秀的廢人");
        Thread thread2 = new Thread(myThread, "在復(fù)習(xí)多線程");

        // 啟動(dòng)線程
        thread1.start();
        thread2.start();

        // 打印當(dāng)前線程的名字
        System.out.println(Thread.currentThread().getName());
    }
}

2亚斋、線程優(yōu)先級

在 Thread 源碼中和線程優(yōu)先級相關(guān)的屬性有以下 3 個(gè)：

// 線程可以擁有的最小優(yōu)先級
public final static int MIN_PRIORITY = 1;

// 線程默認(rèn)優(yōu)先級
public final static int NORM_PRIORITY = 5;

// 線程可以擁有的最大優(yōu)先級
public final static int MAX_PRIORITY = 10

線程的優(yōu)先級可以理解為線程搶占 CPU 時(shí)間片（也就是執(zhí)行權(quán)）的概率作媚，優(yōu)先級越高幾率越大，但并不意味著優(yōu)先級高的線程就一定先執(zhí)行帅刊。

Thread 類中纸泡，設(shè)置優(yōu)先級的源碼如下：

public final void setPriority(int newPriority) {
    ThreadGroup g;
    checkAccess();
    // 先驗(yàn)證優(yōu)先級的合理性，不能大于 10赖瞒，也不能小于 1
    if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
        throw new IllegalArgumentException();
    }
    if((g = getThreadGroup()) != null) {
        // 優(yōu)先級如果超過線程組的最高優(yōu)先級女揭，則把優(yōu)先級設(shè)置為線程組的最高優(yōu)先級（有種一人得道雞犬升天的感覺~）
        if (newPriority > g.getMaxPriority()) {
            newPriority = g.getMaxPriority();
        }
        // native 方法
        setPriority0(priority = newPriority);
    }
}

在 java 中，我們一般這樣設(shè)置線程的優(yōu)先級：

public class TestMain {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();

        //帶參構(gòu)造方法給線程起名字
        Thread thread1 = new Thread(myThread, "一個(gè)優(yōu)秀的廢人");
        Thread thread2 = new Thread(myThread, "在復(fù)習(xí)多線程");

        // 設(shè)置優(yōu)先級
        thread1.setPriority(1);
        thread2.setPriority(10);

        // 啟動(dòng)線程
        thread1.start();
        thread2.start();

        // 打印當(dāng)前線程的名字
        System.out.println(Thread.currentThread().getName());
    }
}

3栏饮、守護(hù)線程

守護(hù)線程是低優(yōu)先級的線程吧兔，專門為其他線程服務(wù)的，其他線程執(zhí)行完了袍嬉，它也就掛了境蔼。在 java 中，我們的垃圾回收線程就是典型的守護(hù)線程伺通。

它有兩個(gè)特點(diǎn)：

• 當(dāng)別的非守護(hù)線程執(zhí)行完了记舆，虛擬機(jī)就會(huì)退出，守護(hù)線程也就會(huì)被停止掉霍殴。
• 守護(hù)線程作為一個(gè)服務(wù)線程单寂，沒有服務(wù)對象就沒有必要繼續(xù)運(yùn)行了。

舉個(gè)栗子：你可以把守護(hù)線程理解為公司食堂里面的員工笑诅，專門為辦公室員工提供飲食服務(wù)调缨，辦公室員工下班回家了疮鲫，它們也就都回家了。所以弦叶，不能使用守護(hù)線程訪問資源（比如修改數(shù)據(jù)俊犯、進(jìn)行I/O 操作等等），因?yàn)檫@貨隨時(shí)掛掉伤哺。反之燕侠，守護(hù)線程經(jīng)常被用來執(zhí)行一些后臺(tái)任務(wù)，但是呢立莉，你又希望在程序退出時(shí)绢彤，或者說 JVM 退出時(shí)，線程能夠自動(dòng)關(guān)閉蜓耻，此時(shí)茫舶，守護(hù)線程是你的首選。

在 java 中刹淌，可以通過 setDaemon 可以設(shè)置守護(hù)線程饶氏，源碼如下：

public final void setDaemon(boolean on) {
    // 判斷是否有權(quán)限
    checkAccess();
    // 判斷是否活躍
    if (isAlive()) {
        throw new IllegalThreadStateException();
    }
    daemon = on;
}

從以上源碼，可以知道必須在線程啟動(dòng)之前就把目標(biāo)線程設(shè)置為守護(hù)線程有勾，否則報(bào)錯(cuò)疹启。

例子：新增一個(gè) DaemonThread，里面執(zhí)行的任務(wù)是死循環(huán)不斷打印自己的線程名字蔼卡。

public class DaemonThread implements Runnable {

    @Override
    public void run() {
        // 死循環(huán)
        while(true) {
          // 打印當(dāng)前線程的名字
          System.out.println(Thread.currentThread().getName());
        }
    }

}

測試：在啟動(dòng)之前先把 thread2 設(shè)置為守護(hù)線程喊崖，thread1 啟動(dòng)，再啟動(dòng) thread2 雇逞。

public class TestMain {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        DaemonThread  daemonThread = new DaemonThread();

        //帶參構(gòu)造方法給線程起名字
        Thread thread1 = new Thread(myThread, "一個(gè)優(yōu)秀的廢人");
        Thread thread2 = new Thread(daemonThread, "在復(fù)習(xí)多線程");

        // 設(shè)置 thread2 為守護(hù)線程
        thread2.setDaemon(true);

        // 啟動(dòng)線程
        thread1.start();
        thread2.start();

        // 打印當(dāng)前線程的名字
        System.out.println(Thread.currentThread().getName());
    }
}

正常來說贷祈，如果 thread2 不是守護(hù)線程，JVM 不會(huì)退出喝峦，除非發(fā)生嚴(yán)重的異常势誊，thread2 會(huì)一直死循環(huán)在控制臺(tái)打印自己的名字。然而谣蠢，設(shè)置為守護(hù)線程之后粟耻，JVM 退出，thread2 也不再執(zhí)行：

守護(hù)線程.png

4眉踱、start() 和 run() 有啥區(qū)別挤忙？

首先從 Thread 源碼來看，start () 方法屬于 Thread 自身的方法谈喳，并且使用了 synchronized 來保證線程安全册烈，源碼如下：

public synchronized void start() {

        // 1、狀態(tài)驗(yàn)證婿禽，不等于 NEW 的狀態(tài)會(huì)拋出異常
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        // 2赏僧、通知線程組大猛，此線程即將啟動(dòng)
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                // 3、不處理任何異常淀零，如果 start0 拋出異常挽绩，則它將被傳遞到調(diào)用堆棧上
            }
        }
}

而 run () 方法為 Runnable 的抽象方法，必須由調(diào)用類重寫此方法驾中，重寫的 run () 方法其實(shí)就是此線程要執(zhí)行的業(yè)務(wù)方法唉堪，源碼如下：

public class Thread implements Runnable {
    // 忽略其他方法......
    private Runnable target;
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
}
@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

關(guān)于兩者區(qū)別這個(gè)問題，其實(shí)上次寫多線程的開篇肩民，已經(jīng)說過了唠亚，有興趣的戳：
這里長話短說，它的區(qū)別是：

• run 方法里面定義的是線程執(zhí)行的任務(wù)邏輯持痰，直接調(diào)用跟普通方法沒啥區(qū)別
• start 方法啟動(dòng)線程灶搜，使線程由 NEW 狀態(tài)轉(zhuǎn)為 RUNNABLE，然后再由 jvm 去調(diào)用該線程的 run () 方法去執(zhí)行任務(wù)
• start 方法不能被多次調(diào)用共啃，否則會(huì)拋出 java.lang.IllegalStateException；而 run () 方法可以進(jìn)行多次調(diào)用暂题，因?yàn)樗莻€(gè)普通方法

5移剪、sleep 方法

sleep 方法的源碼入下，它是個(gè) native 方法薪者。我們沒法看源碼纵苛，只能通過注釋來理解它的含義，我配上了簡短的中文翻譯言津，總結(jié)下來有三點(diǎn)注意：

• 睡眠指定的毫秒數(shù)攻人，且在這過程中不釋放鎖
• 如果參數(shù)非法，報(bào) IllegalArgumentException
• 睡眠狀態(tài)下可以響應(yīng)中斷信號悬槽，并拋出 InterruptedException（后面會(huì)說）
• 調(diào)用 sleep 方法怀吻，即會(huì)從 RUNNABLE 狀態(tài)進(jìn)入 Timed Waiting（計(jì)時(shí)等待）狀態(tài)

/**
     * Causes the currently executing thread to sleep (temporarily cease
     * execution) for the specified number of milliseconds, subject to
     * the precision and accuracy of system timers and schedulers. The thread
     * does not lose ownership of any monitors.

// 1、睡眠指定的毫秒數(shù)初婆，且在這過程中不釋放鎖

     * @param  millis
     *         the length of time to sleep in milliseconds
     *
     * @throws  IllegalArgumentException
     *          if the value of {@code millis} is negative

// 2蓬坡、如果參數(shù)非法，報(bào) IllegalArgumentException
     
     * @throws  InterruptedException
     *          if any thread has interrupted the current thread. The
     *          <i>interrupted status</i> of the current thread is
     *          cleared when this exception is thrown.

// 3磅叛、睡眠狀態(tài)下可以響應(yīng)中斷信號屑咳，并拋出 InterruptedException

*/
public static native void sleep(long millis) throws InterruptedException;

6、如何正確停止線程弊琴？

線程在不同的狀態(tài)下遇到中斷會(huì)產(chǎn)生不同的響應(yīng)兆龙，有點(diǎn)會(huì)拋出異常，有的則沒有變化敲董，有的則會(huì)結(jié)束線程紫皇。

如何正確停止線程慰安？有人說這不簡單嘛。直接 stop 方法坝橡，stop 方法強(qiáng)制終止線程泻帮，所以它是不行的。它已經(jīng)被 Java 設(shè)置為 @Deprecated 過時(shí)方法了计寇。

主要原因是stop 太暴力了锣杂，沒有給線程足夠的時(shí)間來處理在線程停止前保存數(shù)據(jù)的邏輯，任務(wù)就停止了番宁，會(huì)導(dǎo)致數(shù)據(jù)完整性的問題元莫。

舉個(gè)栗子：線程正在寫入一個(gè)文件，這時(shí)收到終止信號蝶押，它就需要根據(jù)自身業(yè)務(wù)判斷踱蠢，是選擇立即停止，還是將整個(gè)文件寫入成功后停止棋电，而如果選擇立即停止就可能造成數(shù)據(jù)不完整茎截，不管是中斷命令發(fā)起者，還是接收者都不希望數(shù)據(jù)出現(xiàn)問題赶盔。

一般情況下企锌，使用 interrupt 方法來請求停止線程，它并不是直接停止于未。它僅僅是給這個(gè)線程發(fā)了一個(gè)信號告訴它撕攒，它應(yīng)該要結(jié)束了 (明白這一點(diǎn)非常重要！)烘浦，而要不要馬上停止抖坪，或者過一段時(shí)間后停止，甚至壓根不停止都是由被停止的線程根據(jù)自己的業(yè)務(wù)邏輯來決定的闷叉。

要了解 interrupt 怎么使用擦俐，先來看看源碼（已經(jīng)給了清晰的注釋）：

 /**
     * Interrupts this thread.

1、只能自己中斷自己握侧，不然會(huì)拋出 SecurityException 

     * <p> Unless the current thread is interrupting itself, which is
     * always permitted, the {@link #checkAccess() checkAccess} method
     * of this thread is invoked, which may cause a {@link
     * SecurityException} to be thrown.

2捌肴、如果線程調(diào)用 wait、sleep藕咏、join 等方法状知，進(jìn)入了阻塞，
會(huì)造成調(diào)用中斷無效孽查，拋 InterruptedException 異常饥悴。

     * <p> If this thread is blocked in an invocation of the {@link
     * Object#wait() wait()}, {@link Object#wait(long) wait(long)}, or {@link
     * Object#wait(long, int) wait(long, int)} methods of the {@link Object}
     * class, or of the {@link #join()}, {@link #join(long)}, {@link
     * #join(long, int)}, {@link #sleep(long)}, or {@link #sleep(long, int)},
     * methods of this class, then its interrupt status will be cleared and it
     * will receive an {@link InterruptedException}.
     *
     * <p> If this thread is blocked in an I/O operation upon an {@link
     * java.nio.channels.InterruptibleChannel InterruptibleChannel}
     * then the channel will be closed, the thread's interrupt
     * status will be set, and the thread will receive a {@link
     * java.nio.channels.ClosedByInterruptException}.
     *
     * <p> If this thread is blocked in a {@link java.nio.channels.Selector}
     * then the thread's interrupt status will be set and it will return
     * immediately from the selection operation, possibly with a non-zero
     * value, just as if the selector's {@link
     * java.nio.channels.Selector#wakeup wakeup} method were invoked.

3、以上三種情況都不會(huì)發(fā)生時(shí)，才會(huì)把線程的中斷狀態(tài)改變

     * <p> If none of the previous conditions hold then this thread's interrupt
     * status will be set. </p>

4西设、中斷已經(jīng)掛了的線程是無效的

     * <p> Interrupting a thread that is not alive need not have any effect.
     *
     * @throws  SecurityException
     *          if the current thread cannot modify this thread
     *
     * @revised 6.0
     * @spec JSR-51
     */
    public void interrupt() {
        // 檢查是否有權(quán)限
        if (this != Thread.currentThread())
            checkAccess();
        
        synchronized (blockerLock) {
             // 判斷是不是阻塞狀態(tài)的線程調(diào)用瓣铣，比如剛調(diào)用 sleep()
            Interruptible b = blocker;
            if (b != null) {
                interrupt0();           // Just to set the interrupt flag
                // 如果是，拋異常同時(shí)推出阻塞贷揽。將中斷標(biāo)志位改為 false
                b.interrupt(this);
                return;
            }
        }
        // 否則棠笑，順利改變標(biāo)志位
        interrupt0();
    }

interrupt 方法提到了四個(gè)點(diǎn)：

• 只能自己中斷自己，不然會(huì)拋出 SecurityException
• 如果線程調(diào)用 wait禽绪、sleep蓖救、join 等方法進(jìn)入了阻塞，會(huì)造成調(diào)用中斷無效印屁，拋 InterruptedException 異常循捺。
• 以上情況不會(huì)發(fā)生時(shí)，才會(huì)把線程的中斷狀態(tài)改變
• 中斷已經(jīng)掛了的線程是無效的

除此以外雄人，java 中跟中斷有關(guān)的方法還有 interrupted() 和 isInterrupted()从橘，看看源碼：

/**
 * Tests whether the current thread has been interrupted.  The
 * <i>interrupted status</i> of the thread is cleared by this method.  In
 * other words, if this method were to be called twice in succession, the
 * second call would return false (unless the current thread were
 * interrupted again, after the first call had cleared its interrupted
 * status and before the second call had examined it).
 *
 * <p>A thread interruption ignored because a thread was not alive
 * at the time of the interrupt will be reflected by this method
 * returning false.
 *
 * @return  <code>true</code> if the current thread has been interrupted;
 *          <code>false</code> otherwise.
 * @see #isInterrupted()
 * @revised 6.0
 */
public static boolean interrupted() {
    return currentThread().isInterrupted(true);
}

/**
 * Tests whether this thread has been interrupted.  The <i>interrupted
 * status</i> of the thread is unaffected by this method.
 *
 * <p>A thread interruption ignored because a thread was not alive
 * at the time of the interrupt will be reflected by this method
 * returning false.
 *
 * @return  <code>true</code> if this thread has been interrupted;
 *          <code>false</code> otherwise.
 * @see     #interrupted()
 * @revised 6.0
 */
public boolean isInterrupted() {
    return isInterrupted(false);
}

/**
 * Tests if some Thread has been interrupted.  The interrupted state
 * is reset or not based on the value of ClearInterrupted that is
 * passed.
 */
private native boolean isInterrupted(boolean ClearInterrupted);

兩個(gè)點(diǎn)：

• isInterrupted() 用于判斷中斷標(biāo)志位，調(diào)用不會(huì)影響當(dāng)前標(biāo)志位
• interrupted() 用于清除中斷標(biāo)志位础钠，調(diào)用會(huì)清除標(biāo)志位

前面說了恰力，interrupt 只是發(fā)個(gè)信號給線程，視線程狀態(tài)把它的中斷標(biāo)志位設(shè)為 true 或者清除（設(shè)置為 false）旗吁，那它會(huì)改變線程狀態(tài)嗎踩萎？前文《線程的狀態(tài)》說過線程有 6 種狀態(tài)，我們來驗(yàn)證每種狀態(tài)的中斷響應(yīng)以及狀態(tài)變更情況：

NEW & TERMINATED

public class StopThread implements Runnable {

    @Override
    public void run() {
        // do something
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new StopThread());
        System.out.println(thread.isInterrupted());
    }
}

運(yùn)行結(jié)果：線程并沒啟動(dòng)阵漏，標(biāo)志不生效

結(jié)果

public class StopThread implements Runnable {

    @Override
    public void run() {
        // do something
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new StopThread());
        thread.start();

        thread.join();
        System.out.println(thread.getState());

        thread.interrupt();

        System.out.println(thread.isInterrupted());
    }
}

運(yùn)行結(jié)果：線程已掛驻民，標(biāo)志并不生效

結(jié)果

RUNNABLE

public class StopThread implements Runnable {

    @Override
    public void run() {
        int count = 0;
        while (true) {
            if (count < 10) {
                System.out.println(count++);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new StopThread());
        thread.start();
        // 查看狀態(tài)
        System.out.println(thread.getState());
        thread.interrupt();
        // 等待 thread 中斷
        Thread.sleep(500);
        // 查看標(biāo)志位
        System.out.println(thread.isInterrupted());
        // 查看狀態(tài)
        System.out.println(thread.getState());
    }
}

運(yùn)行結(jié)果：僅僅設(shè)置中斷標(biāo)志位翻具，JVM 并沒有退出履怯，線程還是處于 RUNNABLE 狀態(tài)。

結(jié)果

看到這里裆泳，有人可能說老子中斷了個(gè)寂寞叹洲？？工禾？正確的中斷寫法應(yīng)該是這樣的：我們通過 Thread.currentThread ().isInterrupt () 判斷線程是否被中斷运提，隨后檢查是否還有工作要做。正確的停止線程寫法應(yīng)該是這樣的：

while (!Thread.currentThread().islnterrupted() && more work to do) {
    do more work
}

在 while 中闻葵，通過 Thread.currentThread ().isInterrupt () 判斷線程是否被中斷民泵，隨后檢查是否還有工作要做。&& 表示只有當(dāng)兩個(gè)判斷條件同時(shí)滿足的情況下槽畔，才會(huì)去執(zhí)行線程的任務(wù)栈妆。實(shí)際例子：

public class StopThread implements Runnable {

    @Override
    public void run() {
        int count = 0;
        while (!Thread.currentThread().isInterrupted() && count < 1000) {
            System.out.println("count = " + count++);
        }
        System.out.println("響應(yīng)中斷退出線程");
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new StopThread());
        thread.start();
        // 查看狀態(tài)
        System.out.println(thread.getState());
        // 中斷
        thread.interrupt();
        // 查看標(biāo)志位
        System.out.println(thread.isInterrupted());
        // 等待 thread 中斷
        Thread.sleep(500);
        // 查看標(biāo)志位
        System.out.println(thread.isInterrupted());
        // 查看狀態(tài)
        System.out.println(thread.getState());
    }
}

結(jié)果

我的業(yè)務(wù)是從 0 開始計(jì)數(shù)，大于 1000 或者線程接收到中斷信號就停止計(jì)數(shù)。調(diào)用 interrupt 鳞尔，該線程檢測到中斷信號嬉橙，中斷標(biāo)記位就會(huì)被設(shè)置成 true，于是在還沒打印完 1000 個(gè)數(shù)的時(shí)候就會(huì)停下來寥假。這樣就不會(huì)有安全問題市框。這種就屬于通過 interrupt 正確停止線程的情況

BLOCKED

首先，啟動(dòng)線程1糕韧、2枫振，調(diào)用 synchronized 修飾的方法，thread1 先啟動(dòng)占用鎖兔沃，thread2 將進(jìn)入 BLOCKED 狀態(tài)蒋得。

public class StopDuringSleep implements Runnable {

    public synchronized static void doSomething(){
        while(true){
            //do something
        }
    }

    @Override
    public void run() {
        doSomething();
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(new StopDuringSleep());
        thread1.start();

        Thread thread2 = new Thread(new StopDuringSleep());
        thread2.start();

        Thread.sleep(1000);
        System.out.println(thread1.getState());
        System.out.println(thread2.getState());

        thread2.interrupt();
        System.out.println(thread2.isInterrupted());
        System.out.println(thread2.getState());
    }
}

運(yùn)行結(jié)果：跟 RUNNABLE 一樣，能響應(yīng)中斷乒疏。

結(jié)果

sleep 期間（WAITING 狀態(tài)）能否感受到中斷额衙？

上面講 sleep 方法時(shí)說過， sleep 是可以響應(yīng)馬上中斷信號怕吴，并清除中斷標(biāo)志位（設(shè)置為 false）窍侧，同時(shí)拋出 InterruptedException 異常，退出計(jì)時(shí)等待狀態(tài)转绷∥凹看看例子：主線程休眠 5 毫秒后，通知子線程中斷议经，此時(shí)子線程仍在執(zhí)行 sleep 語句斧账，處于休眠中。

public class StopDuringSleep implements Runnable {

    @Override
    public void run() {
        int count = 0;
        try {
            while (!Thread.currentThread().isInterrupted() && count < 1000) {
                System.out.println("count = " + count++);
                // 子線程 sleep
                Thread.sleep(1000000);
            }
        } catch (InterruptedException e) {
            // 判斷該線程的中斷標(biāo)志位狀態(tài)
            System.out.println(Thread.currentThread().isInterrupted());
            // 打印線程狀態(tài)
            System.out.println(Thread.currentThread().getState());
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new StopDuringSleep());
        thread.start();
        // 主線程 sleep
        Thread.sleep(5);
        thread.interrupt();
    }

}

運(yùn)行結(jié)果：interrupt 會(huì)把處于 WAITING 狀態(tài)線程改為 RUNNABLE 狀態(tài)

運(yùn)行結(jié)果

僅僅 catch 異常就夠了嗎煞肾？

實(shí)際開發(fā)中往往是團(tuán)隊(duì)協(xié)作咧织，互相調(diào)用。我們的方法中調(diào)用了 sleep 或者 wait 等能響應(yīng)中斷的方法時(shí)籍救，僅僅 catch 住異常而不處理是非常不友好的习绢。這種行為叫屏蔽了中斷請求。

那怎么做才能避免這種情況呢蝙昙？首先可以在方法簽名中拋出異常闪萄，比如：

void subTask2() throws InterruptedException {
    Thread.sleep(1000);
}

Java中，異称娴撸肯定是有調(diào)用方處理的败去。調(diào)用方要么自己拋到上層，要么 try catch 處理烈拒。如果每層邏輯都遵守規(guī)范圆裕，將中斷信號傳遞到頂層三椿，最終讓 run () 方法可以捕獲到異常。雖然 run 方法本身沒有拋出 checkedException 的能力葫辐，但它可以通過 try/catch 根據(jù)業(yè)務(wù)邏輯來處理異常搜锰。

除此以外，還可以在 catch 語句中再次中斷線程耿战。比如上述例子中蛋叼，我們可以在 catch 中這樣寫：

try {
    // 省略代碼
} catch (InterruptedException e) {
    // 判斷該線程的中斷標(biāo)志位狀態(tài)
    System.out.println(Thread.currentThread().isInterrupted());
    // 打印線程狀態(tài)
    System.out.println(Thread.currentThread().getState());
    // 再次中斷
    Thread.currentThread().interrupt();
    // 判斷該線程的中斷標(biāo)志位狀態(tài)
    System.out.println(Thread.currentThread().isInterrupted());
    e.printStackTrace();
}

運(yùn)行結(jié)果：

運(yùn)行結(jié)果

sleep 期間被中斷，會(huì)清除中斷信號將其置為 false剂陡。這時(shí)就需要手動(dòng)在 catch 中再次設(shè)置中斷信號狈涮。如此，中斷信號依然可以被檢測鸭栖，后續(xù)方法仍可知道這里發(fā)生過中斷歌馍，并做出相應(yīng)邏輯處理。

結(jié)論：NEW 和 TERMINATED 狀態(tài)的線程不響應(yīng)中斷晕鹊，其他狀態(tài)可響應(yīng)松却；同時(shí) interrupt 會(huì)把 WAITING & TimeWAITING 狀態(tài)的線程改為 RUNNABLE

7、yield 方法

看 Thread 的源碼可以知道 yield () 為本地方法溅话，也就是說 yield () 是由 C 或 C++ 實(shí)現(xiàn)的晓锻，源碼如下：

/**
 * A hint to the scheduler that the current thread is willing to yield
 * its current use of a processor. The scheduler is free to ignore this
 * hint.
 *
 * <p> Yield is a heuristic attempt to improve relative progression
 * between threads that would otherwise over-utilise a CPU. Its use
 * should be combined with detailed profiling and benchmarking to
 * ensure that it actually has the desired effect.
 *
 * <p> It is rarely appropriate to use this method. It may be useful
 * for debugging or testing purposes, where it may help to reproduce
 * bugs due to race conditions. It may also be useful when designing
 * concurrency control constructs such as the ones in the
 * {@link java.util.concurrent.locks} package.
 */
public static native void yield();

看代碼注釋知道：

• 當(dāng)前線程調(diào)用 yield() 會(huì)讓出 CPU 使用權(quán)，給別的線程執(zhí)行飞几，但是不確保真正讓出砚哆。誰先搶到 CPU 誰執(zhí)行。
• 當(dāng)前線程調(diào)用 yield() 方法屑墨，會(huì)將狀態(tài)從 RUNNABLE 轉(zhuǎn)換為 WAITING躁锁。

比如：

public static void main(String[] args) throws InterruptedException {
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println("線程：" +
                    Thread.currentThread().getName() + " I：" + i);
                if (i == 5) {
                    Thread.yield();
                }
            }
        }
    };
    Thread t1 = new Thread(runnable, "T1");
    Thread t2 = new Thread(runnable, "T2");
    t1.start();
    t2.start();
}

執(zhí)行這段代碼會(huì)發(fā)現(xiàn)，每次的執(zhí)行結(jié)果都不一樣卵史。那是因?yàn)?yield 方法非常不穩(wěn)定战转。

8、join 方法

調(diào)用 join 方法程腹，會(huì)等待該線程執(zhí)行完畢后才執(zhí)行別的線程匣吊。按照慣例儒拂，先來看看源碼：

/**
 * Waits at most {@code millis} milliseconds for this thread to
 * die. A timeout of {@code 0} means to wait forever.
 *
 * <p> This implementation uses a loop of {@code this.wait} calls
 * conditioned on {@code this.isAlive}. As a thread terminates the
 * {@code this.notifyAll} method is invoked. It is recommended that
 * applications not use {@code wait}, {@code notify}, or
 * {@code notifyAll} on {@code Thread} instances.
 *
 * @param  millis
 *         the time to wait in milliseconds
 *
 * @throws  IllegalArgumentException
 *          if the value of {@code millis} is negative
 *
 * @throws  InterruptedException
 *          if any thread has interrupted the current thread. The
 *          <i>interrupted status</i> of the current thread is
 *          cleared when this exception is thrown.
 */
public final synchronized void join(long millis) throws InterruptedException {
    long base = System.currentTimeMillis();
    long now = 0;
    // 超時(shí)時(shí)間不能小于 0
    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }
    // 等于 0 表示無限等待寸潦，直到線程執(zhí)行完為之
    if (millis == 0) {
        // 判斷子線程 (其他線程) 為活躍線程，則一直等待
        while (isAlive()) {
            wait(0);
        }
    } else {
        // 循環(huán)判斷
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay);
            now = System.currentTimeMillis() - base;
        }
    }
}

從源碼知道幾點(diǎn)：

• 從源碼中可以看出 join () 方法底層還是通過 wait () 方法來實(shí)現(xiàn)的社痛。
• 當(dāng)前線程終止见转，會(huì)調(diào)用當(dāng)前實(shí)例的 notifyAll 方法喚醒其他線程。
• 調(diào)用 join 方法蒜哀，會(huì)使當(dāng)前線程從 RUNNABLE 狀態(tài)轉(zhuǎn)至 WAITING 狀態(tài)斩箫。

總結(jié)

Thread 類中主要有 start、run、sleep乘客、yield狐血、join、interrupt 等方法易核，其中start匈织、sleep、yield牡直、join缀匕、interrupt（改變 sleep 狀態(tài)）是會(huì)改變線程狀態(tài)的。最后碰逸，上一張完成版的線程狀態(tài)切換圖：

線程的 6 種狀態(tài)

福利

如果看到這里乡小，喜歡這篇文章的話，請幫點(diǎn)個(gè)好看饵史。微信搜索一個(gè)優(yōu)秀的廢人满钟，關(guān)注后回復(fù)電子書送你 100+ 本編程電子書 ，不只 Java 哦胳喷，詳情看下圖零远。回復(fù) 1024送你一套完整的 java 視頻教程厌蔽。

資源

C語言

C++

Java

Git

Python

GO

Linux

經(jīng)典必讀

面試相關(guān)

前端

人工智能

設(shè)計(jì)模式

數(shù)據(jù)庫

數(shù)據(jù)結(jié)構(gòu)與算法

計(jì)算機(jī)基礎(chǔ)