1方灾、基礎(chǔ)梳理

1. 進(jìn)程和線程滤祖。1). 進(jìn)程是操作系統(tǒng)正在執(zhí)行的不同應(yīng)用程序的一個(gè)實(shí)例定踱，線程是操作系統(tǒng)分配處理器時(shí)間的基本單元棍潘。2). 每個(gè)進(jìn)程運(yùn)行在自己的地址空間，而線程共享數(shù)據(jù)內(nèi)存和 IO 這些資源崖媚。
2. 線程的優(yōu)缺點(diǎn)亦歉。優(yōu)點(diǎn)：1). 程序的運(yùn)行效率可能會(huì)更高；2). 可以使用線程把占用時(shí)間較長的任務(wù)放在后臺(tái)去執(zhí)行畅哑；3). 在一些等待耗時(shí)任務(wù)和交互事件的時(shí)候同時(shí)可以執(zhí)行其他任務(wù)肴楷。缺點(diǎn)：1).如果有大量的線程,會(huì)影響性能,因?yàn)椴僮飨到y(tǒng)需要在它們之間切換；2).更多的線程需要更多的內(nèi)存空間荠呐；3).通常塊模型數(shù)據(jù)是在多個(gè)線程間共享的,需要防止線程死鎖情況的發(fā)生赛蔫。

2、使用線程

2.1 使用 Thread 創(chuàng)建單線程

Java 中提供了 Thread 類用來創(chuàng)建線程泥张。當(dāng)我們調(diào)用 Thread 的 start() 方法的之后呵恢，Thread 的 run() 方法將會(huì)被調(diào)用。默認(rèn)的圾结，Thread 的 run() 方法中會(huì)調(diào)用傳入的 Runnable 的 run() 方法執(zhí)行任務(wù)瑰剃，我們也可以覆寫 Thread 的 run() 方法來讓它直接執(zhí)行我們的業(yè)務(wù)邏輯。所以筝野，可以使用下面的兩種方式使用線程晌姚，

    /**
    * 方式 1：覆寫 run() 方法使用線程
    * 按照下面的方式來啟動(dòng)線程即可粤剧，
    * MyThread myThread = new MyThread(); 
    * myThread.start(); 
    */
    private class MyThread extends Thread {
        @Override
        public void run() {
            // 業(yè)務(wù)邏輯
        }
    }

    /**
    * 方式 2：使用 Runnable 使用線程
    */
    new Thread(new Runnable() {
        public void run() {
            // 業(yè)務(wù)邏輯
        }
    }).start();

對(duì)第二種方式，在創(chuàng)建多個(gè)線程的情況下挥唠，如果傳入的 Runnable 實(shí)例是同一個(gè)實(shí)例的話抵恋，那么這幾個(gè)線程是共享這個(gè)實(shí)例的數(shù)據(jù)的；如果不是同一個(gè)實(shí)例宝磨，則每個(gè)線程有一份自己的數(shù)據(jù)弧关。當(dāng)共享實(shí)例的時(shí)候，有時(shí)需要引入同步機(jī)制唤锉。

2.2 使用 Executor 創(chuàng)建線程池

2.2.1 線程池的基本使用

使用線程池的好處在于：因?yàn)榫€程的創(chuàng)建和銷毀會(huì)占有一定的資源開銷世囊，尤其是當(dāng)線程需要執(zhí)行的邏輯耗時(shí)比較短，而創(chuàng)建和銷毀的時(shí)間占用比較長的時(shí)候窿祥，對(duì)每個(gè)任務(wù)都創(chuàng)建和銷毀線程就不太劃算了株憾。而線程池為我們提供了一種復(fù)用線程的機(jī)制，我們可以只創(chuàng)建執(zhí)行數(shù)量的線程晒衩，然后將任務(wù)不斷地提交到線程池中執(zhí)行嗤瞎。

Executors 類有許多靜態(tài)工程方法可以用來構(gòu)建線程池：

1. newCachedThreadPool()：對(duì)每個(gè)任務(wù)，如果有空閑線程听系，立即讓它執(zhí)行任務(wù)贝奇，若無，則創(chuàng)建新線程靠胜；
2. newFixedThreadPool()：構(gòu)建一個(gè)具有固定大小的線程池掉瞳，若提交的任務(wù)數(shù)目大于空閑線程，得不到服務(wù)的任務(wù)放在隊(duì)列中髓帽，執(zhí)行完其他任務(wù)再執(zhí)行這些任務(wù)菠赚；
3. newSingleThreadPool()：大小為1的線程池，提交的任務(wù)會(huì)按照提交的順序依次地被執(zhí)行（執(zhí)行完畢一個(gè)郑藏，才去執(zhí)行另一個(gè)）衡查；
4. newWorkStealingPool()：具有Work-Stealing (工作竊取) 的能力的線程池，Java8 中引入的必盖，基于分治思想拌牲，Java8 中的并行流就是基于它來實(shí)現(xiàn)的。

使用線程池的時(shí)候歌粥，除了像線程那樣啟動(dòng)任何塌忽，還可以獲取到線程執(zhí)行的結(jié)果。ExecutorService 的 submit() 方法提供了多個(gè)重載的版本失驶，我們可以將 Runnable 或者 Callable 作為任務(wù)來執(zhí)行土居。對(duì)于 Callable 類型的任務(wù)，該方法定義如下，

    <T> Future<T> submit(Callable<T> task)

也就是說擦耀，我們可以通過方法的返回結(jié)果得到一個(gè) Future 實(shí)例棉圈。我們可以使用這個(gè)實(shí)例的方法來獲取任務(wù)的執(zhí)行結(jié)果，只是它的方法都是阻塞的眷蜓。因此分瘾，我們又有了第三種使用線程的方式，

    // 方式 3：使用線程池并獲取線程的執(zhí)行結(jié)果
    // 定義固定大小的線程池
    ExecutorService executor = Executors.newFixedThreadPool(5);
    // 定義一個(gè)列表用來存儲(chǔ) submit 的返回實(shí)例
    List<Future<Integer>> results = new ArrayList<Future<Integer>>();
    for (int i=0; i<5; i++) {
        results.add(executor.submit(new CallableTask(i, i)));
    }
    // 輸出每個(gè)任務(wù)的執(zhí)行結(jié)果
    for (Future<Integer> result : results) {
        try {
            // 線程將會(huì)在 get() 方法上面阻塞
            System.out.println(result.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

此外吁系，也可以使用 Future 的 isDone() 方法來判斷任務(wù)是否完成德召，并決定是否要調(diào)用 get() 方法。

另外汽纤，還有一個(gè)類叫做 FutureTask上岗。它同時(shí)實(shí)現(xiàn)了 Future 和 Runnable，所以蕴坪，它設(shè)計(jì)的目的在于讓我們可以同時(shí)從 FutureTask 實(shí)例中設(shè)置任務(wù)并獲取結(jié)果液茎。FutureTask 提供了兩個(gè)構(gòu)造方法，分別接受一個(gè) Callable 和 Runnable 類型的實(shí)例辞嗡。所以，我們可以把自己的任務(wù)放進(jìn) FutureTask 中包裝了之后再傳遞給 ExectorService 或者 Thread 來執(zhí)行滞造。

2.2.2 線程池的參數(shù)選擇

上面我們使用的是線程池的默認(rèn)實(shí)現(xiàn)续室，也就是使用 Executors 的靜態(tài)方法提供的線程池。這種方式是沒有問題的谒养，但是當(dāng)我們使用阿里的插件的時(shí)候挺狰，會(huì)發(fā)現(xiàn)阿里并不推薦我們這樣使用，而是使用手動(dòng)創(chuàng)建線程池的方式买窟。所以丰泊，在創(chuàng)建線程池的時(shí)候，我們有幾個(gè)參數(shù)需要決定始绍，

以 Android 為例瞳购，它并沒有明確規(guī)定可以創(chuàng)建的線程的數(shù)量，但是每個(gè)進(jìn)程的資源是有限的亏推，線程本身會(huì)占有一定的資源学赛，所以受內(nèi)存大小的限制，會(huì)有數(shù)量的上限吞杭。通常盏浇，我們在使用線程或者線程池的時(shí)候，不會(huì)創(chuàng)建太多的線程芽狗。線程池的大小經(jīng)驗(yàn)值應(yīng)該這樣設(shè)置：（其中 N 為 CPU 的核數(shù)）

1. 如果是 CPU 密集型應(yīng)用绢掰，則線程池大小設(shè)置為 N + 1；(大部分時(shí)間在計(jì)算)
2. 如果是 IO 密集型應(yīng)用，則線程池大小設(shè)置為 2N + 1滴劲；(大部分時(shí)間在讀寫攻晒，Android)

下面是 Android 中的 AysncTask 中創(chuàng)建線程池的代碼（一些參數(shù)的意義已經(jīng)添加到了注釋種），

    // CPU 的數(shù)量
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    // 核心線程的數(shù)量：只有提交任務(wù)的時(shí)候才會(huì)創(chuàng)建線程哑芹，當(dāng)當(dāng)前線程數(shù)量小于核心線程數(shù)量炎辨，新添加任務(wù)的時(shí)候，會(huì)創(chuàng)建新線程來執(zhí)行任務(wù)
    private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
    // 線程池允許創(chuàng)建的最大線程數(shù)量：當(dāng)任務(wù)隊(duì)列滿了聪姿，并且當(dāng)前線程數(shù)量小于最大線程數(shù)量碴萧，則會(huì)創(chuàng)建新線程來執(zhí)行任務(wù)
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    // 非核心線程的閑置的超市時(shí)間：超過這個(gè)時(shí)間，線程將被回收末购，如果任務(wù)多且執(zhí)行時(shí)間短破喻，應(yīng)設(shè)置一個(gè)較大的值
    private static final int KEEP_ALIVE_SECONDS = 30;

    // 線程工廠：自定義創(chuàng)建線程的策略，比如定義一個(gè)名字
    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);

        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };

    // 任務(wù)隊(duì)列：如果當(dāng)前線程的數(shù)量大于核心線程數(shù)量盟榴，就將任務(wù)添加到這個(gè)隊(duì)列中
    private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(128);

    public static final Executor THREAD_POOL_EXECUTOR;

    static {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                /*corePoolSize=*/ CORE_POOL_SIZE,
                /*maximumPoolSize=*/ MAXIMUM_POOL_SIZE, 
                /*keepAliveTime=*/ KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                /*workQueue=*/ sPoolWorkQueue, 
                /*threadFactory=*/ sThreadFactory
                /*handler*/ defaultHandler); // 飽和策略：AysncTask 沒有這個(gè)參數(shù)
        threadPoolExecutor.allowCoreThreadTimeOut(true);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }

飽和策略：任務(wù)隊(duì)列和線程池都滿了的時(shí)候執(zhí)行的邏輯曹质，Java 提供了 4 種實(shí)現(xiàn)；
其他：

1. 當(dāng)調(diào)用了線程池的 prestartAllcoreThread() 方法的時(shí)候擎场，線程池會(huì)提前啟動(dòng)并創(chuàng)建所有核心線程來等待任務(wù)羽德；
2. 當(dāng)調(diào)用了線程池的 allowCoreThreadTimeOut() 方法的時(shí)候，超時(shí)時(shí)間到了之后迅办，閑置的核心線程也會(huì)被移除宅静。

3、線程狀態(tài)和生命周期

3.1 線程的狀態(tài)

[圖片上傳失敗...(image-fa054e-1554730026011)]

Java中的線程的生命周期大體可分為 5 種狀態(tài)：

1. 新建 (NEW)：新創(chuàng)建了一個(gè)線程對(duì)象站欺。

2. 可運(yùn)行 (RUNNABLE)：線程對(duì)象創(chuàng)建后姨夹，其他線程(比如 main 線程）調(diào)用了該對(duì)象的 start() 方法。該狀態(tài)的線程位于可運(yùn)行線程池中矾策，等待被線程調(diào)度選中磷账，獲取 CPU 的使用權(quán) 。

3. 運(yùn)行 (RUNNING)：RUNNABLE 狀態(tài)的線程獲得了 CPU 時(shí)間片（timeslice） 贾虽，執(zhí)行程序代碼逃糟。

4. 阻塞 (BLOCKED)：阻塞狀態(tài)是指線程因?yàn)槟撤N原因放棄了 CPU 使用權(quán)，也即讓出了 CPU timeslice蓬豁，暫時(shí)停止運(yùn)行履磨。直到線程進(jìn)入 RUNNABLE 狀態(tài)，才有機(jī)會(huì)再次獲得 CPU timeslice 轉(zhuǎn)到 RUNNING 狀態(tài)庆尘。阻塞的情況分三種：

   1. 等待阻塞：RUNNING 的線程執(zhí)行 o.wait() 方法剃诅，JVM 會(huì)把該線程放入等待隊(duì)列 (waitting queue) 中。

   2. 同步阻塞：RUNNING 的線程在獲取對(duì)象的同步鎖時(shí)驶忌，若該同步鎖被別的線程占用矛辕，則 JVM 會(huì)把該線程放入鎖池 (lock pool) 中笑跛。

   3. 其他阻塞：RUNNING 的線程執(zhí)行 Thread.sleep(long) 或 t.join() 方法，或者發(fā)出了 I/O 請求時(shí)聊品，JVM 會(huì)把該線程置為阻塞狀態(tài)飞蹂。當(dāng) sleep() 狀態(tài)超時(shí)、join() 等待線程終止或者超時(shí)翻屈、或者 I/O 處理完畢時(shí)陈哑，線程重新轉(zhuǎn)入 RUNNABLE 狀態(tài)。

5. 死亡 (DEAD)：線程 run()伸眶、main() 方法執(zhí)行結(jié)束惊窖，或者因異常退出了 run() 方法，則該線程結(jié)束生命周期厘贼。死亡的線程不可再次復(fù)生界酒。

線程的 wait() 和 notify() 調(diào)度原理：

[圖片上傳失敗...(image-7951c6-1554730026011)]

3.2 線程的啟動(dòng) start()、停止 stop()嘴秸、掛起 suspend() 和喚醒 resume()

通過對(duì)象的 start(), stop(), suspend(), resume() 方法可以分別用來啟動(dòng)/停止/掛起/繼續(xù)線程毁欣，但是后面三種方法都已經(jīng)過時(shí)，調(diào)用可能發(fā)生不可預(yù)料的結(jié)果岳掐。如果線程被停止或者掛起的時(shí)候凭疮，它仍然占有共享的資源，那么有可能會(huì)導(dǎo)致線程死鎖串述。

說明：調(diào)用 start() 方法哭尝，線程處于 runnable，線程可運(yùn)行剖煌，但是無法確定線程是否正在運(yùn)行，這取決于操作系統(tǒng)提供的運(yùn)行時(shí)間逝淹。

run()方法執(zhí)行結(jié)束之后耕姊，線程自動(dòng)終止；如果 run() 無限循環(huán)栅葡，可以考慮加加標(biāo)識(shí)茉兰，在一定情況下退出，不推薦使用 stop() 方法欣簇。另外规脸，如果線程終止了，將無法再次啟動(dòng)熊咽。

一個(gè)線程會(huì)結(jié)束的原因可能是下面兩者之一：1).run() 方法正常退出而線程自然地死亡莫鸭；2).一個(gè)沒有被捕獲的異常終止了 run() 方法而意外地死亡。

3.3 線程休眠 Thread.sleep()

靜態(tài)方法 Thread.sleep(long millis) 和 Thread.sleep(long millis, int nanos) 強(qiáng)行將當(dāng)前線程休眠（暫停執(zhí)行）指定時(shí)間横殴，睡眠結(jié)束被因，即返回可運(yùn)行狀態(tài)。

此外，也可以使用 TimeUnit.MILLISECONDS.sleep(1000); 方法來實(shí)現(xiàn)線程的休眠梨与。

注意：

1. 一個(gè)線程不能針對(duì)另一個(gè)線程調(diào)用 Thread.sleep()堕花，即一個(gè)線程只能讓自己睡眠；
2. sleep() 方法會(huì)拋出一個(gè) InterruptedException 異常粥鞋。
3. 如果當(dāng)前線程獲得了鎖缘挽，sleep() 方法并不會(huì)使其失去鎖。

另外呻粹，對(duì)于 sleep() 和 wait() 方法之間的區(qū)別壕曼，總結(jié)如下，

1. 所屬類不同：sleep() 方法是 Thread 的靜態(tài)方法尚猿，而 wait() 是 Object 實(shí)例方法窝稿。
2. 作用域不同：wait() 方法必須要在同步方法或者同步塊中調(diào)用，也就是必須已經(jīng)獲得對(duì)象鎖凿掂。而 sleep() 方法沒有這個(gè)限制可以在任何地方種使用伴榔。
3. 鎖占用不同：wait() 方法會(huì)釋放占有的對(duì)象鎖，使得該線程進(jìn)入等待池中庄萎，等待下一次獲取資源踪少。而 sleep() 方法只是會(huì)讓出 CPU 并不會(huì)釋放掉對(duì)象鎖；
4. 鎖釋放不同：sleep() 方法在休眠時(shí)間達(dá)到后如果再次獲得 CPU 時(shí)間片就會(huì)繼續(xù)執(zhí)行糠涛，而 wait() 方法必須等待 Object.notift()/Object.notifyAll() 通知后援奢，才會(huì)離開等待池，并且再次獲得 CPU 時(shí)間片才會(huì)繼續(xù)執(zhí)行忍捡。

3.4 線程優(yōu)先級(jí) setPriority()

優(yōu)先級(jí)使用正整數(shù)試著集漾，通常為 0~10，默認(rèn)為 5. Thread類中也定義了 3 個(gè)靜態(tài)最終常量：Thread.MIN_PRIORITY (對(duì)應(yīng)整數(shù)值為 1)砸脊、Thread.NORM_PRIORITY (對(duì)應(yīng)整數(shù)值為 5) 和 Thread.MAX_PRIORITY (對(duì)應(yīng)整數(shù)值為 10).

線程是根據(jù)優(yōu)先級(jí)調(diào)度執(zhí)行的具篇，盡管 CPU 處理現(xiàn)有的線程集的順序是不確定的，但是調(diào)度器傾向于讓優(yōu)先權(quán)最高的線程先執(zhí)行凌埂。這不意味著優(yōu)先權(quán)低的程序得不到執(zhí)行，只是執(zhí)行的頻率較低瞳抓。

說明：

1. 默認(rèn)情況下埃疫，一個(gè)線程繼承它父線程的優(yōu)先級(jí)，可以使用 setPriority() 方法提高或降低一個(gè)線程的優(yōu)先級(jí)孩哑；
2. 高優(yōu)先級(jí)線程沒有進(jìn)入非活動(dòng)狀態(tài)栓霜，低優(yōu)先級(jí)線程永遠(yuǎn)不可能執(zhí)行。每當(dāng)調(diào)用一個(gè)新線程時(shí)横蜒，首先會(huì)在具有高優(yōu)先級(jí)的線程中選擇叙淌。盡管這樣可能會(huì)使低優(yōu)先級(jí)線程完全餓死秤掌；
3. 在絕大多數(shù)的時(shí)間里，線程都應(yīng)該以默認(rèn)的優(yōu)先級(jí)運(yùn)行鹰霍，試圖操縱線程優(yōu)先級(jí)通常是一種錯(cuò)誤闻鉴。
4. 在不同 JVM 以及操作系統(tǒng)上，線程規(guī)劃存在差異茂洒，有些操作系統(tǒng)甚至?xí)雎跃€程優(yōu)先級(jí)的設(shè)定孟岛。

3.5 讓步 Thread.yield()

即暫停當(dāng)前正在執(zhí)行的線程對(duì)象，并執(zhí)行其他線程督勺。并非永久暫停渠羞，只是讓步一次執(zhí)行時(shí)間片。需要注意的是智哀，讓出的CPU并不是代表當(dāng)前線程不再運(yùn)行了次询，如果在下一次競爭中，又獲得了 CPU 時(shí)間片當(dāng)前線程依然會(huì)繼續(xù)運(yùn)行瓷叫。另外屯吊，讓出的時(shí)間片只會(huì)分配給當(dāng)前線程相同優(yōu)先級(jí)的線程。

yield() 是 Thread 的一個(gè)靜態(tài)方法摹菠，它給線程調(diào)度機(jī)制一個(gè)暗示：當(dāng)前線程（在 run() 方法中調(diào)用 yield() 方法的線程）的工作已經(jīng)差不多了盒卸，可以讓別的線程使用 CPU 了。

但是次氨，大體上蔽介，對(duì)任何重要的控制或在調(diào)整應(yīng)用時(shí)，都不能依賴于 yield().

另外需要注意的是煮寡，sleep() 和 yield() 方法虹蓄，同樣都是當(dāng)前線程會(huì)交出處理器資源。它們不同的是幸撕，sleep() 交出來的時(shí)間片其他線程都可以去競爭薇组，也就是說都有機(jī)會(huì)獲得當(dāng)前線程讓出的時(shí)間片。而 yield() 方法只允許與當(dāng)前線程具有相同優(yōu)先級(jí)的線程能夠獲得釋放出來的 CPU 時(shí)間片杈帐。

3.6 加入一個(gè)線程 join()

join() 是 Thread 的實(shí)例方法，它用來等待专钉，直到指定線程結(jié)束挑童。如果我們在線程 A 中調(diào)用了 B 的 join() 方法，就表示我們將 A 添加到了 B 的尾部跃须，如果 B 不執(zhí)行完 A 不繼續(xù)執(zhí)行站叼。join() 重載版本，

void join()                         // 加入線程菇民，等待該線程終止后運(yùn)行
void join(long millis)              // 加入線程尽楔，等待該線程 millis 后運(yùn)行投储，0 為無限等待
void join(long millis, int nanos)   // 加入線程，等待該線程 millis+nanos 后運(yùn)行

線程的 join() 方法允許傳入 long 型的時(shí)間阔馋，表示我們可以為線程設(shè)置等待的時(shí)間上限玛荞。當(dāng)超過了指定的時(shí)間另一個(gè)線程仍然沒有執(zhí)行完畢任務(wù)，當(dāng)前線程就繼續(xù)執(zhí)行自己的任務(wù)呕寝。否則勋眯，當(dāng)前線程會(huì)一直阻塞。

注意下梢，因?yàn)榫€程的 join() 方法的本意是等待另一份線程直到結(jié)束客蹋，所以，如果我們沒有對(duì)指定的線程調(diào)用 start() 方法孽江，那么 join() 是沒有效果的（因?yàn)榫€程本來就沒啟動(dòng)讶坯，所以也不用等待了）。

3.7 線程中斷 interrupt()

線程中斷需要注意兩種情形岗屏，一個(gè)是未處于阻塞時(shí)期的中斷辆琅，另一個(gè)是處于阻塞時(shí)期的中斷

interrupt() 方法用來中斷線程，而不是立即終止線程担汤。對(duì)線程調(diào)用 interrupt() 方法時(shí)涎跨，線程的中斷狀態(tài)將被置位（設(shè)置為 true），這是每個(gè)線程都具有的 boolean 狀態(tài)崭歧。如果想要知道一個(gè)線程是否被置位隅很，可以使用 Thread.currentThread().isInterrupted() 來判斷。

當(dāng)線程由于調(diào)用了 sleep(), wait(), join() 等方法而進(jìn)入阻塞狀態(tài)率碾；若此時(shí)調(diào)用線程的 interrupt() 將線程的中斷標(biāo)記設(shè)為 true叔营。由于處于阻塞狀態(tài)，中斷標(biāo)記會(huì)被清除所宰，同時(shí)產(chǎn)生一個(gè) InterruptedException 異常绒尊。

所以，當(dāng)你希望讓一個(gè)線程從阻塞狀態(tài)中結(jié)束的時(shí)候仔粥，你可以按照下面這樣去寫婴谱，

@Override
public void run() {
    try {
        while (true) {
            // do something
        }
    } catch (InterruptedException ie) {  
        // 由于 InterruptedException 異常，退出 while 循環(huán)躯泰，線程終止谭羔！
    }
}

通常，我們把對(duì) InterruptedException 的捕獲務(wù)一般放在 while 循環(huán)體的外面麦向，這樣瘟裸，在產(chǎn)生異常時(shí)就退出了 while 循環(huán)。

讓線程結(jié)束诵竭，你還可以通過判斷中斷標(biāo)志位來進(jìn)行话告。此外兼搏，你還可以通過使用一個(gè)額外的布爾類型的變量來讓線程退出。

    // 通過判斷中斷標(biāo)志位來退出
    private static class MyRunnable implements Runnable {

        @Override
        public void run() {
            while (!Thread.currentThread().isInterrupted()) {
                // do something
            }
        }
    }

    // 通過一個(gè)布爾類型的變量來退出
    private static class MyRunnable2 implements Runnable {
        // 注意使用 volatile 修飾
        private volatile boolean canceled = false;

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

        public void cancel() {
            canceled = true;
        }
    }

上面的第一種方式還沒有考慮線程被阻塞的情況沙郭，所以佛呻，我們需要綜合線程是否處于阻塞來給出一個(gè)更完美的版本，

@Override
public void run() {
    try {
        while (!isInterrupted()) {
            // do something
        }
    } catch (InterruptedException ie) {  
        // 線程因?yàn)樽枞麜r(shí)被中斷而結(jié)束了循環(huán)
    }
}

最后棠绘，注意 interrupted() 和 isInterrupted() 的區(qū)別

interrupted() 是屬于 Thread 的靜態(tài)方法件相，isInterrupted() 是屬于 Thread 的實(shí)例方法。interrupted() 和 isInterrupted() 都能夠用于檢測對(duì)象的 “中斷標(biāo)記”氧苍。區(qū)別是夜矗，interrupted() 除了返回中斷標(biāo)記之外，它還會(huì)清除中斷標(biāo)記 (即將中斷標(biāo)記設(shè)為false)让虐；而 isInterrupted() 僅僅返回中斷標(biāo)記紊撕。

    public static boolean interrupted() {
        return currentThread().isInterrupted(/* ClearInterrupted= */ true);
    }

    public boolean isInterrupted() {
        return isInterrupted(/* ClearInterrupted= */ false);
    }

3.8 后臺(tái)線程

Java 線程分為兩類：用戶線程和 Daemon 線程。

1. 用戶線程是通常意義的線程赡突，Java 應(yīng)用程序運(yùn)行時(shí)对扶，通過 main() 方法進(jìn)入. 在主線程中可以創(chuàng)建和啟動(dòng)新線程，默認(rèn)為用戶線程. 只有所有用戶線程結(jié)束后惭缰，應(yīng)用程序才終止浪南。
2. 通過 setDaemon() 方法，可以設(shè)置線程為 Daemon 線程漱受，在 Daemon 線程中創(chuàng)建的線程默認(rèn)為 Daemon 線程. 通過方法 isDaemon() 可以判斷一個(gè)線程是否為 Daemon 線程络凿。
3. Daemon 線程（守護(hù)線程）是一個(gè)服務(wù)線程，其 優(yōu)先級(jí)最低昂羡，一般為其他線程提供服務(wù). 通常 Daemon 線程體是一個(gè)無限循環(huán)絮记，如果所有的非 Daemon 線程都結(jié)束了，則 Daemon 線程自動(dòng)終止虐先。
4. Daemon 線程應(yīng)該永遠(yuǎn)不訪問固有資源怨愤，如文件、數(shù)據(jù)等蛹批，因?yàn)樗鼤?huì)在任何時(shí)候撰洗，甚至任一個(gè)操作中間發(fā)生中斷。
5. Deamon 線程通常是系統(tǒng)服務(wù)類線程腐芍，比如垃圾回收線程差导，JIT線程就可以理解守護(hù)線程。

3.9 線程組

最好把線程組看作一次不好的嘗試甸赃，忽略就好柿汛。

3.10 線程控制 wait()冗酿、notify() 和 notifyAll()

1. wait()埠对、notify() 和 notifyAll() 方法是 Object 的本地 final 方法络断，無法被重寫。

2. wait() 使當(dāng)前線程阻塞项玛，直到接到通知或被中斷為止貌笨。前提是必須先獲得鎖，一般配合 synchronized 關(guān)鍵字使用襟沮，在 synchronized 同步代碼塊里使用 wait()锥惋、notify() 和 notifyAll() 方法。如果調(diào)用 wait() 或者 notify() 方法時(shí)开伏，線程并未獲取到鎖的話膀跌，則會(huì)拋出 IllegalMonitorStateException 異常。再次獲取到鎖固灵，當(dāng)前線程才能從 wait() 方法處成功返回捅伤。

3. 由于 wait()、notify() 和 notifyAll() 在 synchronized 代碼塊執(zhí)行巫玻，說明當(dāng)前線程一定是獲取了鎖的丛忆。當(dāng)線程執(zhí)行 wait() 方法時(shí)候，會(huì)釋放當(dāng)前的鎖仍秤，然后讓出 CPU熄诡，進(jìn)入等待狀態(tài)。只有當(dāng) notify()/notifyAll() 被執(zhí)行時(shí)候诗力，才會(huì)喚醒一個(gè)或多個(gè)正處于等待狀態(tài)的線程凰浮，然后繼續(xù)往下執(zhí)行，直到執(zhí)行完 synchronized 代碼塊或是中途遇到 wait()姜骡，再次釋放鎖导坟。
   也就是說，notify()/notifyAll() 的執(zhí)行只是喚醒沉睡的線程圈澈，而不會(huì)立即釋放鎖惫周，鎖的釋放要看代碼塊的具體執(zhí)行情況。所以在編程中康栈，盡量在使用了 notify()/notifyAll() 后立即退出臨界區(qū)递递，以喚醒其他線程。

4. wait() 需要被 try catch 包圍啥么，中斷也可以使 wait 等待的線程喚醒登舞。

5. notify() 和 wait() 的順序不能錯(cuò)，如果 A 線程先執(zhí)行 notify() 方法悬荣，B 線程再執(zhí)行 wait() 方法菠秒，那么 B 線程是無法被喚醒的。

6. notify() 和 notifyAll() 的區(qū)別：
   notify() 方法只喚醒一個(gè)等待（對(duì)象的）線程并使該線程開始執(zhí)行。所以如果有多個(gè)線程等待一個(gè)對(duì)象践叠，這個(gè)方法只會(huì)喚醒其中一個(gè)線程言缤，選擇哪個(gè)線程取決于操作系統(tǒng)對(duì)多線程管理的實(shí)現(xiàn)。
   notifyAll() 會(huì)喚醒所有等待 (對(duì)象的) 線程禁灼，盡管哪一個(gè)線程將會(huì)第一個(gè)處理取決于操作系統(tǒng)的實(shí)現(xiàn)管挟。如果當(dāng)前情況下有多個(gè)線程需要被喚醒，推薦使用 notifyAll() 方法弄捕。比如在生產(chǎn)者-消費(fèi)者里面的使用僻孝，每次都需要喚醒所有的消費(fèi)者或是生產(chǎn)者，以判斷程序是否可以繼續(xù)往下執(zhí)行守谓。