摘要：當線程執(zhí)行完后進入狀態(tài)，表示線程執(zhí)行結(jié)束。其中和表示兩個線程。但要注意，讓出并不表示當前線程不執(zhí)行了。關(guān)鍵字其作用是防止指令重排和使線程對一個對象的修改令其他線程可見。

Java Memory Model的關(guān)鍵技術(shù)點都是圍繞著多線程的原子性、可見性和有序性來建立的。因此我們首先需要來了解這些概念。

原子性是指一個操作是不可中斷的。即使是在多個線程一起執(zhí)行的時候，一個人操作一旦開始，就不會被其他的線程干擾。

比如對一個靜態(tài)全局變量int i，兩個線程同時對它賦值，線程A給他賦值1，線程B給它賦值為-1.那么不管這么2個線程以合作方式、何種步調(diào)工作，i的值要么是1，要么是-1。線程A和B之間是沒有干擾的。這就是原子性的一個特點，不可被中斷。

可見性是指當一個線程修改了某一個共享變量的值，其他線程是否能夠立即知道這個修改。顯然，對于串行程序來說，可見性問題是不存在的。因為你在任何一個操作步驟中修改了某個變量，那么在后續(xù)的步驟中，讀取這個變量的值，一定是修改后的新值。

有序性問題是三個問題中最難理解的。對于一個線程的執(zhí)行代碼而言，我們總是習慣地認為代碼的執(zhí)行是從先往后，依次執(zhí)行。這么理解也不是說完全錯誤，因為就一個線程內(nèi)而言，確實會表現(xiàn)成這樣。但是，在并發(fā)時，程序的執(zhí)行可能就會出現(xiàn)亂序。給人直觀的感覺就是：寫在前面的代碼，會在后面執(zhí)行。然而有序性的問題的原因因為是程序在執(zhí)行時，可能會進行指令重排，重排后的指令與原指令的順序未必一致。 那么在這里由于篇幅關(guān)系就不在展開介紹，有興趣的讀者可以自行搜索Java指令重排和CPU流水線等資料。

雖然Java虛擬機和執(zhí)行系統(tǒng)會對指令進行一定的重排，但是指令重排是有規(guī)則的，并非所有的指令都可以隨便改變位置。原則基本包括以下：

程序順序原則：一個線程內(nèi)保證語義的串行性

  a=1;
  b=a+1;
  //第二條語句依賴于第一條執(zhí)行結(jié)果。所以不允許指令重排。

volatile規(guī)則：volatile變量的寫，先發(fā)生與讀，這保證了volatile變量的可見性。一般用volatile修飾的都是經(jīng)常修改的對象。

鎖規(guī)則：解鎖（unlock）必然發(fā)生在隨后的加鎖（lock）前

傳遞性：A先于B，B先于C，那么A必然先于C

線程的start（）方法先于它的每一個動作

線程的所有操作先于線程的終結(jié)（Thread.join()）

線程的中斷（interrupt()）先于被中斷線程的代碼

對象的構(gòu)造函數(shù)執(zhí)行、結(jié)束先于finalize()方法

線程所有的狀態(tài)都在Thread.State枚舉類中定義：

public enum State {
    /**
    * 表示剛剛創(chuàng)建的線程，這種線程還沒開始執(zhí)行。
    **/
    NEW,
    /**
    * 調(diào)用start()方法后，線程開始執(zhí)行，處于RUNNABLE狀態(tài)，
    * 表示線程所需要的一切資源以及準備好。
    **/
    RUNNABLE,
    /**
    * 當線程遇到synchronized同步塊，就進入了BLOCKED阻塞狀態(tài)。
    * 這時線程會暫停執(zhí)行，直到獲得請求的鎖。
    **/
    BLOCKED,
    /**
    * WAITING和TIMED_WAITING都表示等待狀態(tài)，他們是區(qū)別是WAITING表示進入一個無時間限制的等待
    * TIMED_WAITING會進入一個有時間限制的等待。
    * WAITING的狀態(tài)正是在等待特殊的事件，如notify()方法。而通過join()方法等待的線程，則是等待目標線程的終止。
    * 一旦等到期望的時間，線程就會繼續(xù)執(zhí)行，進入RUNNABLE狀態(tài)。
    * 當線程執(zhí)行完后進入TERMINATED狀態(tài)，表示線程執(zhí)行結(jié)束。
    **/
    WAITING,
    TIMED_WAITING,
    TERMINATED;
}

新建線程很簡單。只要使用new關(guān)鍵字創(chuàng)建一個線程對象，并且將其start()起來即可。start()方法額就會新建一個線程并讓這個線程執(zhí)行run()方法。

常見就是有人直接對一個線程對象執(zhí)行run()方法，那么只會在當前的線程中串行執(zhí)行run()中的代碼 。

最后要說的是，默認的Thread.run()就是直接調(diào)用內(nèi)部的Runnable接口。因此，使用Runnable接口告訴線程該做什么，更為合理。

Stop()方法是用不得的，會直接終止運行中的線程，并立刻釋放鎖。比如一個線程寫數(shù)據(jù)到一般被中止，則會寫壞。

那么最簡單的方法可以考慮給線程做一個死循環(huán)，然后對一個類似Flag的變量進行判斷，變量變化時退出循環(huán)。JDK所提供的線程中斷也是類似于此。

線程中斷是重要的線程協(xié)作機制，中斷就是讓線程停止執(zhí)行，但這個停止執(zhí)行非stop()的暴力方式。JDK提供了更安全的支持，就是線程中斷。
線程中斷并不會使線程立即停止，而是給線程發(fā)送一個通知，告訴目標線程有人希望你退出。至于目標線程接到通知后什么時候停止，完全由目標線程自行決定。這點很重要，如果線程接到通知后立即退出，我們就又會遇到類似stop()方法的老問題。
與線程有關(guān)的三個方法，

中斷線程

void Thread.interrupt()

說明：Thread.interrupt() 是一個實例方法，他通知目標線程中斷，也就是設置中斷標志位。中斷標志位表示當前線程已經(jīng)被中斷了。

判斷是否被中斷

boolean Thread.isInterrupted()

說明：Thread.isInterrupted() 也是實例方法，他判斷當前線程是否被中斷（通過檢查中斷標志位）

判斷是否被中斷，并清除當前中斷狀態(tài)

static boolean Thread.interrupted()

說明：Thread.interrupted() 是靜態(tài)方法，判斷當前線程的中斷狀態(tài)，但同時會清除當前線程的中斷標志位狀態(tài)。

Thread.sleep()方法會讓當前線程休眠若干時間，它會拋出一個interruptedException中斷異常。interruptedException是必須被捕獲的——當線程在sleep時，如果被中斷，這個異常就產(chǎn)生。

public class InterruptExample {

    public static void main(String [] a) throws InterruptedException{

        Thread t1 = new Thread("線程小哥 - 1 "){
            @Override
            public void run() {
                while (true){
                    /**
                     * 必須得判斷是否接受到中斷通知,如果不寫退出方法,也無法將當前線程退出.
                     */
                    if (Thread.currentThread().isInterrupted()){
                        System.out.println(Thread.currentThread().getName() + " Interrupted ... ");
                        break;
                    }

                    try {
                        /**
                         * 處理業(yè)務邏輯花費10秒.
                         * 而在這時,主線程發(fā)送了中斷通知,當線程在sleep的時候如果收到中斷
                         * 則會拋出InterruptedException,如果在異常中不處理,則線程不會中斷.
                         *
                         */
                        Thread.sleep(10000);
                    } catch (InterruptedException e) {
                        System.out.println("線程在睡眠中遭到中斷....");
                        /**
                         * 在sleep過程中,收到中斷通知,拋出異常.可以直接退出線程.
                         * 但如果還需要處理其他業(yè)務,則需要重新中斷自己.設置中斷標記位.
                         * 這樣在下次循環(huán)的時候 線程發(fā)現(xiàn)中斷通知,才能正確的退出.
                         */
                        Thread.currentThread().interrupt();
                    }

                    Thread.yield();
                }
            }
        };

        t1.start();
        try {
            /**
             * 處理業(yè)務500毫秒
             * 然后發(fā)送中斷通知,此時t1線程還在sleep中.
             */
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        /**
         * 給目標線程發(fā)送中斷通知
         * 目標線程中必須有處理中斷通知的代碼
         * 否則,就算發(fā)送了通知,目標線程也無法停止.
         */
        t1.interrupt();
    }
}

為了支持多線程之間的協(xié)作，JDK提供了兩個非常重要的等待方法wait()和nofity()方法。這兩個方法并不是Thread類中的，而是Object類，這意味著任何對象都可以調(diào)用這兩個方法。

這兩個方法的簽名如下：

public final void wait() throws InterruptedException
public final native void notify()

如果一個線程調(diào)用了object.wait()方法，那么這個線程就會停止執(zhí)行而轉(zhuǎn)為等待狀態(tài)，進入obj對象的等待隊列。這個等待隊列可能有多個線程，因為系統(tǒng)運行多個線程同時等待同一個對象。其他線程調(diào)用obj.notify()方法時，它就會從等待隊列中隨機選擇一個線程并將其喚醒。注意這個選擇是不公平的，是隨機的。

object.wait()方法并不是可以隨便調(diào)用。它必須包含在對應的synchronized語句中。無論是wait還是notify都必須首先獲得目標對象的一個監(jiān)視器 。如下圖，顯示了wait()和nofity的工作流程細節(jié)。其中T1和T2表示兩個線程。T1在正確執(zhí)行wait方法后，首先必須獲得object對象的監(jiān)視器。而wait方法在執(zhí)行后，會釋放這個監(jiān)視器，這樣做的目的使得其他等待object對象上的線程不至于因為T1的休眠而全部無法正常執(zhí)行。

線程T2在notify()調(diào)用前，也必須獲得object的監(jiān)聽器。所幸，此時T1已經(jīng)釋放了這個監(jiān)視器。因此，T2可以順利獲得object的監(jiān)視器。接著，T2執(zhí)行了notify()方法嘗試喚醒一個等待線程，這里假設喚醒了T1。T1在被喚醒后，要做的第一件事并不是執(zhí)行后續(xù)的代碼，而是要嘗試重新獲得object的監(jiān)視器。而這個監(jiān)視器也正是T1在wait()方法執(zhí)行前所持有的那個。如果暫時無法獲得，T1還必須要等待這個監(jiān)視器。當監(jiān)視器順利獲得后，T1才可以真正意義上的繼續(xù)執(zhí)行。

注意：：Object.wait()和Thread.sleep()方法都可以讓線程等待若干的時間。除了wait()可以被喚醒外，另一個最主要的區(qū)別就是wait()方法會釋放目標對象的鎖，而Thread.sleep()方法不會釋放任何資源。

不推薦使用suspend()去掛起線程 的原因是因為suspend()在導致線程暫停的同時，并不會去釋放任何資源。此時，其他任何線程都想訪問它暫用的鎖時，都會被導致牽連，導致無法正常運行。直到對應的線程上進行了resume()操作，被掛起的線程才能繼續(xù)，從而其他所有阻塞在相關(guān)鎖上的線程也可以繼續(xù)執(zhí)行。但是，如果resume()操作意外地在suspend()前就執(zhí)行了，那么被掛起的線程可能就很難有機會被繼續(xù)執(zhí)行。并且，更嚴重的是：它鎖占用的鎖不會被釋放，因此可能會導致整個操作系統(tǒng)工作不正常。而且，對于被掛起的線程，從它的線程上看狀態(tài)，居然會是Runnable，這是最氣的。

join的方法簽名：

public final void join () throws InterruptedException //一直阻塞當前線程，直到目標線程執(zhí)行完畢
public final synchronized void join (long millis) throws InterruptedException//和之前一樣，不過增加了最大等待時間

public static native void yield();

這是一個靜態(tài)方法，一旦執(zhí)行，它會使當前線程讓出CPU。但要注意，讓出CPU并不表示當前線程不執(zhí)行了。當前線程在讓出CPU以后，還會進行CPU資源爭奪，但是是否能夠再次分配到就要看人品了。

如果你覺得一個線程不那么重要，或者優(yōu)先級非常低，而且又害怕它會占用太多的CPU資源，那么可以在適當?shù)臅r候調(diào)用Thread.yield()，給予其他重要線程更多的工作機會。

其作用是防止CPU指令重排和使線程對一個對象的修改令其他線程可見。

對于Java的內(nèi)存模型來說，每個volatile會在線程的工作內(nèi)存從保留一個拷貝，只不過java內(nèi)存模型通過對volatile變量的添加了特殊機制保證了變量的可見性。線程在修改volatile類型變量以后必須立即保存到主內(nèi)存，在使用變量前必須從主內(nèi)存加載數(shù)據(jù)，同時還做了一些禁止指令重排序的操作。對于各個線程的工作內(nèi)存（私有內(nèi)存）來說，存在volatile變量不一致的時刻，但是對于執(zhí)行引擎來說，通過了上面的幾條規(guī)則保證了變量是一致的。

可參考： Java并發(fā)編程之volatile關(guān)鍵字解析

并行程序開發(fā)的一大關(guān)注重點就是線程安全。一般來說，程序并行化就是為了獲得更高的執(zhí)行效率，但前提是，不能以犧牲正確性為代價。如果程序并行化以后，連基本的執(zhí)行結(jié)果都無法保證，那么并行程序本身也就沒有任何意義了。

volatile并不能真正的保障線程安全。它只能確保一個線程修改了數(shù)據(jù)后，其他線程能夠看到這個改動。但當兩個線程同時修改某一個數(shù)據(jù)時，卻依然會產(chǎn)生沖突。

關(guān)鍵字synchronized的作用是實現(xiàn)線程間的同步。它的工作是對同步的代碼加鎖，使得每一次，只能有一個線程進入同步塊，從而保證線程間的安全。

關(guān)鍵字synchronized可以有多種用法：

指定加鎖對象：對給定對象加鎖，進入同步代碼前要獲得給定對象的鎖。

直接作用于實例方法：相當于對當前實例加鎖，進入同步代碼前要獲得當前實例的鎖。

直接作用于靜態(tài)方法：相當于對當前類加鎖，進入同步代碼前要獲得當前類的鎖。