多线程（初级篇）
相關概念
進程是指一個內存中運行的應用程序，每個進程都有自己獨立的一塊內存空間，一個進程中可以啟動多個線程。
一個進程是一個獨立的運行環境，它可以被看作一個程序或者一個應用。而線程是在進程中執行的一個任務。Java運行環境是一個包含了不同的類和程序的單一進程。線程可以被稱為輕量級進程。線程需要較少的資源來創建和駐留在進程中，并且可以共享進程中的資源。
多線程程序中，多個線程被并發的執行以提高程序的效率，CPU不會因為某個線程需要等待資源而進入空閑狀態。多個線程共享堆內存(heap memory)，因此創建多個線程去執行一些任務會比創建多個進程更好。舉個例子，Servlets比CGI更好，是因為Servlets支持多線程而CGI不支持。
這里所謂的多個線程“同時”執行是人的感覺，實際上，是多個線程輪換執行。
線程調度器（ThreadScheduler）是一個操作系統服務，它負責為Runnable狀態的線程分配CPU時間。一旦我們創建一個線程并啟動它，它的執行便依賴于線程調度器的實現。
時間分片（Time Slicing）是指將可用的CPU時間分配給可用的Runnable線程的過程。分配CPU時間可以基于線程優先級或者線程等待的時間。線程調度并不受到Java虛擬機控制，所以由應用程序來控制它是更好的選擇（也就是說不要讓你的程序依賴于線程的優先級）。
線程的生命周期
線程的生命周期有五個狀態。
新建(New)：線程對象已經創建，還沒有在其上調用start()方法；
就緒(Runnable)：當線程有資格運行，但調度程序還沒有把它選定為運行線程時線程所處的狀態。當start()方法調用時，線程首先進入就緒狀態。在線程運行之后或者從阻塞、等待或睡眠狀態回來后，也返回到可運行狀態。
運行(Running)：線程調度程序從可運行池中選擇一個線程作為當前線程時線程所處的狀態。這也是線程進入運行狀態的唯一一種方式。
阻塞(Blocked)：這是線程有資格運行時它所處的狀態，線程仍舊是活的，但是當前沒有條件運行。換句話說，它是可運行的，但是如果某件事件出現，他可能返回到可運行狀態。
阻塞的情況分三種：
1、等待阻塞：運行的線程執行wait()方法，JVM會把該線程放入等待池中。
2、同步阻塞：運行的線程在獲取對象的同步鎖時，若該同步鎖被別的線程占用，則JVM會把該線程放入鎖池中。
3、其他阻塞：運行的線程執行sleep()或join()方法，或者發出了I/O請求時，JVM會把該線程置為阻塞狀態。當sleep()狀態超時、join()等待線程終止或者超時、或者I/O處理完畢時，線程重新轉入就緒狀態。
終止：當線程的run()方法完成時就認為它死去。這個線程對象也許是活的，但是，它已經不是一個單獨執行的線程。線程一旦死亡，就不能復生。如果在一個死去的線程上調用start()方法，會拋出java.lang.IllegalThreadStateException異常。
如下圖所示：
各狀態間的轉換條件如下圖所示：
線程的創建
有兩種方法可以創定義、創建線程：
1、繼承java.lang.Thread類
一個Thread類實例只是一個對象，像Java中的任何其他對象一樣，具有變量和方法，生死于堆上。
public class ThreadInstance extends Thread{@Overridepublic void run() {for(int i=0;i<5;i++){System.out.println(name+":"+"第"+i+"次執行");}}public ThreadInstance(String name){this.name = name;}private String name ; }?測試類： Thread threadA = new ThreadInstance("threadA");Thread threadB = new ThreadInstance("threadB");Thread threadC = new ThreadInstance("threadC");threadA.start();threadB.start();threadC.start();打印結果：
threadA:第0次執行
threadC:第0次執行
threadB:第0次執行
threadC:第1次執行
threadA:第1次執行
threadC:第2次執行
threadB:第1次執行
threadB:第2次執行
threadB:第3次執行
threadB:第4次執行
threadC:第3次執行
threadA:第2次執行
threadC:第4次執行
threadA:第3次執行
threadA:第4次執行
注意：由于程序運行當時，CPU狀態不同，線程調度器的工作狀態不同，每次的打印結果并不一致。
假如我們不調用start()方法，而是直接調用run()方法，會怎樣呢？將測試代碼作如下改動：
Thread threadA = new ThreadInstance("threadA");Thread threadB = new ThreadInstance("threadB");Thread threadC = new ThreadInstance("threadC");threadA.run();threadB.run();threadC.run();打印結果：
threadA:第0次執行
threadA:第1次執行
threadA:第2次執行
threadA:第3次執行
threadA:第4次執行
threadB:第0次執行
threadB:第1次執行
threadB:第2次執行
threadB:第3次執行
threadB:第4次執行
threadC:第0次執行
threadC:第1次執行
threadC:第2次執行
threadC:第3次執行
threadC:第4次執行
此次的打印結果是按照Thread實例的先后順序執行的，這不是偶然的。從本質上講，run()方法就是Thread實例的一個成員方法，如果我們直接調用，就跟調用其他成員方法一樣，不會由于線程的的調度而產生阻塞、執行的狀態，而會一直執行完畢，完畢之前后面的程序不會執行。先執行threadA.run()，完畢后再執行threadB.run()，完畢后再執行threadC.run()。所以它并不是一個多線程程序
雖然start()也是調用run()方法來執行相關任務的，但是start()方法只是讓線程進入可執行狀態（就緒狀態），等待cpu分配給它時間片，并不一定會立刻執行。這時可能有多個線程處在可執行狀態，線程調度器輪流分配給它們時間片。所以它是一個多線程程序。
2、實現java.lang.Runnable接口
必須實現Runnable接口中的run()方法，跟Thread類中的run()方法一樣，線程執行的任務需要寫在run()方法中。
public class RunnableInstance implements Runnable{@Overridepublic void run() {for(int i=0;i<5;i++){System.out.println(Thread.currentThread().getName()+":"+"第"+i+"次執行");}} }Thread的構造方法可接受一個Runnable的實例，用Runnable的run()方法覆蓋掉Thread類的run()方法。
? ?
RunnableInstance r1 = new RunnableInstance();Thread threadA = new Thread(r1,"threadA");RunnableInstance r2 = new RunnableInstance();Thread threadB = new Thread(r2,"threadB");RunnableInstance r3 = new RunnableInstance();Thread threadC = new Thread(r3,"threadC");threadA.start();threadB.start();threadC.start();打印結果：
threadA:第0次執行
threadB:第0次執行
threadA:第1次執行
threadB:第1次執行
threadA:第2次執行
threadB:第2次執行
threadC:第0次執行
threadC:第1次執行
threadC:第2次執行
threadC:第3次執行
threadC:第4次執行
threadA:第3次執行
threadA:第4次執行
threadB:第3次執行
threadB:第4次執行
執行效果與Thread的效果類似。
在測試程序中，每個Thread持有一個Runnable實例，互不干擾。試想，如果讓Thread共享一個Runnable實例，會發生什么情況呢？
RunnableInstance r1 = new RunnableInstance();Thread threadA = new Thread(r1,"threadA");//RunnableInstance r2 = new RunnableInstance();Thread threadB = new Thread(r1,"threadB");//RunnableInstance r3 = new RunnableInstance();Thread threadC = new Thread(r1,"threadC");threadA.start();threadB.start();threadC.start();打印結果：
threadA:第0次執行
threadA:第1次執行
threadC:第0次執行
threadB:第0次執行
threadC:第1次執行
threadA:第2次執行
threadC:第2次執行
threadB:第1次執行
threadC:第3次執行
threadA:第3次執行
threadC:第4次執行
threadB:第2次執行
threadB:第3次執行
threadB:第4次執行
threadA:第4次執行
可見，與原來的測試結果類似，并沒有特別的地方。
這是因為沒有出現多線程競爭同一個資源的情況。將Runnable接口改動如下：
public class RunnableInstance implements Runnable{@Overridepublic void run() {while(count > 0){count = count-10;System.out.println(Thread.currentThread().getName()+"取出10元，余額："+count);}}private int count = 100;}在進行測試，打印結果如下：
threadA取出10元，余額：80
threadC取出10元，余額：70
threadB取出10元，余額：80
threadB取出10元，余額：40
threadC取出10元，余額：50
threadC取出10元，余額：20
threadC取出10元，余額：10
threadC取出10元，余額：0
threadA取出10元，余額：60
threadB取出10元，余額：30
結果顯然不正常。
這是因為多個線程同時對同一實例中的統一數據進行了讀取操作造成的。為了避免這種情況，使共享數據在同一時刻只能有一個線程進行讀取，這就是線程的同步控制。
3、補充
1、一個運行中的線程總是有名字的，名字有兩個來源，一個是虛擬機自己給的名字，一個是你自己的定的名字。在沒有指定線程名字的情況下，虛擬機總會為線程指定名字，并且主線程的名字總是mian，非主線程的名字不確定。
2、線程都可以設置名字，也可以獲取線程的名字，連主線程也不例外。
3、獲取當前線程的對象的方法是：Thread.currentThread()；
4、在上面的代碼中，只能保證：每個線程都將啟動，每個線程都將運行直到完成。一系列線程以某種順序啟動并不意味著將按該順序執行。對于任何一組啟動的線程來說，調度程序不能保證其執行次序，持續時間也無法保證。
5、當線程目標run()方法結束時該線程完成。
6、一旦線程啟動，它就永遠不能再重新啟動。只有一個新的線程可以被啟動，并且只能一次。一個可運行的線程或死線程可以被重新啟動。
7、線程的調度是JVM的一部分，在一個CPU的機器上上，實際上一次只能運行一個線程。一次只有一個線程棧執行。JVM線程調度程序決定實際運行哪個處于可運行狀態的線程。眾多可運行線程中的某一個會被選中做為當前線程。可運行線程被選擇運行的順序是沒有保障的。
8、盡管通常采用隊列形式，但這是沒有保障的。隊列形式是指當一個線程完成“一輪”時，它移到可運行隊列的尾部等待，直到它最終排隊到該隊列的前端為止，它才能被再次選中。事實上，我們把它稱為可運行池而不是一個可運行隊列，目的是幫助認識線程并不都是以某種有保障的順序排列成個一個隊列的事實。
9、盡管我們沒有無法控制線程調度程序，但可以通過別的方式來影響線程調度的方式，比如設置優先級，以及調用Thread.sleep()，wait()，yield()等方法。
線程的狀態裝換
sleep()方法
Thread.sleep(long millis)和Thread.sleep(long millis,int nanos)靜態方法強制當前正在執行的線程休眠（暫停執行），以“減慢線程”。當線程睡眠時，它入睡在某個地方，在蘇醒之前不會返回到可運行狀態。當睡眠時間到期，則返回到可運行狀態。但它并不釋放對象鎖。也就是說如果有synchronized同步快，其他線程仍然不能訪問共享數據。
例如，在前面的例子中，模擬一個耗時的操作，以減慢線程的執行。可以這么寫：
public class ThreadInstance extends Thread{private String name ;@Overridepublic void run() {for(int i=1;i<9;i++){if(i%3 == 0){try {System.out.println(name+"睡眠0.02秒");Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(name+":"+"第"+i+"次執行");}}public ThreadInstance(String name){this.name = name;}public static void main(String[] args) {Thread threadA = new ThreadInstance("threadA");Thread threadB = new ThreadInstance("threadB");Thread threadC = new ThreadInstance("threadC");threadA.start();threadB.start();threadC.start();} }打印結果：
threadA:第1次執行
threadC:第1次執行
threadB:第1次執行
threadC:第2次執行
threadA:第2次執行
threadC睡眠2秒
threadB:第2次執行
threadA睡眠2秒
threadB睡眠2秒
threadC:第3次執行
threadC:第4次執行
threadC:第5次執行
threadC睡眠2秒
threadA:第3次執行
threadB:第3次執行
threadA:第4次執行
threadB:第4次執行
threadA:第5次執行
threadB:第5次執行
threadA睡眠2秒
threadB睡眠2秒
threadC:第6次執行
threadC:第7次執行
threadC:第8次執行
threadA:第6次執行
threadA:第7次執行
threadA:第8次執行
threadB:第6次執行
threadB:第7次執行
threadB:第8次執行
?
為了讓其他線程有機會執行，將Thread.sleep()的調用放線程run()之內。這樣才能保證該線程執行過程中會睡眠。
1、線程睡眠是幫助所有線程獲得運行機會的最好方法。
2、線程睡眠到期自動蘇醒，并返回到就緒狀態，不是運行狀態。sleep()中指定的時間是線程不會運行的最短時間。因此，sleep()方法不能保證該線程睡眠到期后就開始執行。
3、sleep()是靜態方法，只能控制當前正在運行的線程。
yield()方法
線程的讓步是通過Thread.yield()來實現的。yield()方法的作用是：暫停當前正在執行的線程對象，并執行其他線程。
要理解yield()，必須了解線程的優先級的概念。線程總是存在優先級，優先級范圍在1~10之間。JVM線程調度程序是基于優先級的搶先調度機制。在大多數情況下，當前運行的線程優先級將大于或等于線程池中任何線程的優先級。但這僅僅是大多數情況。
注意：當設計多線程應用程序的時候，一定不要依賴于線程的優先級。因為線程調度優先級操作是沒有保障的，優先級越高只能代表它獲取cpu資源的概率比較大。只能把線程優先級作用作為一種提高程序效率的方法，但是要保證程序不依賴這種操作。
當線程池中線程都具有相同的優先級，調度程序的JVM實現自由選擇它喜歡的線程。這時候調度程序的操作有兩種可能：一是選擇一個線程運行，直到它阻塞或者運行完成為止。二是時間分片，為池內的每個線程提供均等的運行機會。
設置線程的優先級：線程默認的優先級是創建它的執行線程的優先級。可以通過setPriority(int newPriority)更改線程的優先級。例如：
?
Thread t = new MyThread();t.setPriority(8);t.start();線程優先級為1~10之間的正整數，JVM從不會改變一個線程的優先級。然而，1~10之間的值是沒有保證的。一些JVM可能不能識別10個不同的值，而將這些優先級進行每兩個或多個合并，變成少于10個的優先級，則兩個或多個優先級的線程可能被映射為一個優先級。
線程默認優先級是5，Thread類中有三個常量，定義線程優先級范圍：
?
static int MAX_PRIORITY
????????? 線程可以具有的最高優先級。
static int MIN_PRIORITY
????????? 線程可以具有的最低優先級。
static int NORM_PRIORITY
????????? 分配給線程的默認優先級。
?
yield()應該做的是讓當前運行線程回到可運行狀態，以允許具有相同優先級的其他線程獲得運行機會。因此，使用yield()的目的是讓相同優先級的線程之間能適當的輪轉執行。但是，實際中無法保證yield()達到讓步目的，因為讓步的線程還有可能被線程調度程序再次選中。
yield()從未導致線程轉到等待/睡眠/阻塞狀態。在大多數情況下，yield()將導致線程從運行狀態轉到就緒狀態，但有可能沒有效果。
join()方法
join() 方法主要是讓調用該方法的thread完成run方法里面的東西后，再執行join()方法后面的代碼。示例：
public class ThreadInstance extends Thread{public static int count = 5 ;@Overridepublic void run() {for(int i=0;i<5;i++){count--;System.out.print(count+",");}}public static void main(String[] args) {Thread threadA = new ThreadInstance();threadA.start();System.out.println(ThreadInstance.count);} }打印結果如下：
5
4,3,2,1,0,
就是說，System.out.println(ThreadInstance.count)這條語句打印出的結果為“5”，而不是“0”。
這是因為在上面的程序中存在兩個線程，一個是主線程main，一個是子線程threadA。兩個線程并發執行，threadA.start()只是讓threadA進入就緒狀態，并不一定會立即執行。同時main主線程不會等待threadA執行完畢，而是執行后面的語句，此時靜態變量count還沒有被threadA改變，打印出的結果是“5”。
如果想保證threadA執行完畢之后再執行后面的語句，就需要用到join()方法了。將程序修改如下：
public class ThreadInstance extends Thread{public static int count = 5 ;@Overridepublic void run() {for(int i=0;i<5;i++){count--;System.out.print(count+",");}System.out.println();}public static void main(String[] args)throws InterruptedException {Thread threadA = new ThreadInstance();threadA.start();threadA.join();System.out.println(ThreadInstance.count);} }打印結果如下：
4,3,2,1,0,
0
可見，join()方法保證了threadA執行完畢之后采取執行后面的語句。
在上例中，main線程是執行threadA的線程，join從字面上理解是“加入”的意思，就是表示把該線程加入到調用該線程的線程，保證其執行完畢再進行下一步的工作。
另外，join()方法還有帶超時限制的重載版本。例如threadA.join(5000);則讓線程等待5000毫秒，如果超過這個時間，則停止等待，變為可運行狀態。
interrupt()方法
首先來說說java中的中斷機制，Java中斷機制是一種協作機制，也就是說通過中斷并不能直接終止另一個線程，而需要被中斷的線程自己處理中斷。當調用interrupt()方法的時候，只是設置了要中斷線程的中斷狀態，而此時被中斷的線程的可以通過非靜態方法isInterrupted()或者是靜態方法interrupted()方法判斷當前線程的中斷狀態是否標志為中斷。
來看一個例子：
class ATask implements Runnable{ private double d = 0.0; public void run() { //死循環執行打印"I am running!" 和做消耗時間的浮點計算 while (true) { System.out.println("I am running!"); for (int i = 0; i < 900000; i++){ d = d + (Math.PI + Math.E) / d; } } } } public class InterruptTaskTest { public static void main(String[] args)throws Exception{ //將任務交給一個線程執行 Thread t = new Thread(new ATask()); t.start(); //運行一斷時間中斷線程 Thread.sleep(100); System.out.println("****************************"); System.out.println("InterruptedThread!"); System.out.println("****************************"); t.interrupt(); } }運行這個程序，我們發現調用interrupt()后，程序仍在運行，如果不強制結束，程序將一直運行下去，如下所示:
I am running!?
I am running!?
I am running!?
I am running!?
****************************?
InterruptedThread!?
****************************?
I am running!?
I am running!?
I am running!?
I am running!?
I am running!?
....?
interrupt()只是改變中斷狀態而已。interrupt()不會中斷一個正在運行的線程。這一方法實際上完成的是，給受阻塞的線程拋出一個中斷信號，
這樣受阻線程就得以退出阻塞的狀態。更確切地說，如果線程被Object.wait, Thread.join和Thread.sleep三種方法之一阻塞，那么，它將接收到一個中斷異常（InterruptedException），從而提早地終結被阻塞狀態。
如果線程沒有被阻塞，這時調用interrupt()將不起作用；否則，線程就將得到InterruptedException異常（該線程必須事先預備好處理此狀況），接著逃離阻塞狀態。
離開線程有兩種常用的方法：
拋出InterruptedException和用Thread.interrupted()檢查是否發生中斷，下面分別看一下這兩種方法：
1、在阻塞操作時如Thread.sleep()時被中斷會拋出InterruptedException(注意，進行不能中斷的IO操作而阻塞和要獲得對象的鎖調用對象的synchronized方法而阻塞時不會拋出InterruptedException)
?
class ATask implements Runnable{ private double d = 0.0; public void run() { //死循環執行打印"I am running!" 和做消耗時間的浮點計算 try { while (true) { System.out.println("I am running!"); for (int i = 0; i < 900000;i++) { d = d + (Math.PI + Math.E) / d; } //休眠一斷時間，在休眠的過程中接收到中斷信號，會拋出InterruptedException Thread.sleep(50); } } catch (InterruptedException e) { System.out.println("ATask.run() interrupted!"); } } }打印結果：
I am running!?
I am running!?
****************************?
InterruptedThread!?
****************************?
ATask.run() interrupted!
?
2、Thread.interrupted()檢查是否發生中斷。Thread.interrupted()能告訴你線程是否發生中斷，并將清除中斷狀態標記，所以程序不會兩次通知你線程發生了中斷
?
class ATask implements Runnable{ private double d = 0.0; public void run() { //檢查程序是否發生中斷 while (!Thread.interrupted()) { System.out.println("I am running!"); for (int i = 0; i < 900000; i++){ d = d + (Math.PI + Math.E) /d; } } System.out.println("ATask.run()interrupted!"); } }打印結果：
I am running!?
I am running!?
I am running!?
I am running!?
I am running!?
I am running!?
I am running!?
****************************?
InterruptedThread!?
****************************?
ATask.run()interrupted!
?
但這其實是在sleep,wait,join這些方法內部會不斷檢查中斷狀態的值，而自己拋出的InterruptedException。
當線程A終于執行到wait(),sleep(),join()時，才馬上會拋出InterruptedException。
若沒有調用sleep(),wait(),join()這些方法,即沒有在線程里自己檢查中斷狀態自己拋出InterruptedException的話，那InterruptedException是不會被拋出來的。
我們可結合使用兩種方法來達到可以通過interrupt()中斷線程。請看下面例子：
class ATask implements Runnable{ private double d = 0.0; public void run() { try { //檢查程序是否發生中斷 while (!Thread.interrupted()) { System.out.println("I am running!"); Thread.sleep(20); System.out.println("Calculating"); for (int i = 0; i < 900000; i++){ d = d + (Math.PI + Math.E) / d; } } } catch (InterruptedException e) { System.out.println("Exiting byException"); } System.out.println("ATask.run()interrupted!"); } }還有一點需要特別注意，Thread.stop()也是讓線程中斷的靜態方法，與Thread .interrupt() 最大的區別在于：interrupt（）方法是設置線程的中斷狀態，讓用戶自己選擇時間地點去結束線程；而stop（）方法會在代碼的運行處直接拋出一個ThreadDeath錯誤，這是一個java.lang.Error的子類。所以直接使用stop()方法就有可能造成對象的不一致性。
Thread.stop()不推薦使用。
其他方法
除了以上方法，Thread類中還有JDK舊版本的遺留方法。
suspend() /resume()方法對：suspend()是線程掛起，直到調用resume()方法使之恢復到就緒狀態。
因為這對方法具有死鎖傾向，JDK只是為了兼容舊版本而保留，不推薦使用。
?
stop()方法：無論該線程在做些什么，它所代表的線程都被迫異常停止，并拋出一個新創建的 ThreadDeath 對象，作為異常。
該方法具有固有的不安全性。JDK只是為了兼容舊版本而保留，不推薦使用。
補充
到目前位置，介紹了線程離開運行狀態的3種方法：
1、調用Thread.sleep()：使當前線程睡眠至少多少毫秒（盡管它可能在指定的時間之前被中斷）。
2、調用Thread.yield()：不能保障太多事情，盡管通常它會讓當前運行線程回到可運行性狀態，使得有相同優先級的線程有機會執行。
3、調用join()方法：保證當前線程停止執行，直到該線程所加入的線程完成為止。然而，如果它加入的線程沒有存活，則當前線程不需要停止。
4、這里要明確的一點，不管程序員怎么編寫調度，只能最大限度的影響線程執行的次序，而不能做到精準控制。
?
除了以上三種方式外，還有下面幾種特殊情況可能使線程離開運行狀態：
1、線程的run()方法完成。
2、在對象上調用wait()方法（不是在線程上調用）。
3、線程不能在對象上獲得鎖定，它正試圖運行該對象的方法代碼。
4、線程調度程序可以決定將當前運行狀態移動到可運行狀態，以便讓另一個線程獲得運行機會，而不需要任何理由。
線程的同步
由于同一進程的多個線程共享同一片存儲空間，在帶來方便的同時，也帶來了訪問沖突這個嚴重的問題。Java語言提供了專門機制以解決這種沖突，有效避免了同一個數據對象被多個線程同時訪問。
在具體的Java代碼中需要完成一下兩個操作：
1、把競爭訪問的資源變量標識為private；
2、同步哪些修改變量的代碼，使用synchronized關鍵字同步方法或代碼。
當然這不是唯一控制并發安全的途徑。
同步
Java中每個對象都有一個內置鎖。
當程序運行到非靜態的synchronized同步方法上時，自動獲得與正在執行代碼類的當前實例（this實例）有關的鎖。獲得一個對象的鎖也稱為獲取鎖、鎖定對象、在對象上鎖定或在對象上同步。
當程序運行到synchronized同步方法或代碼塊時才該對象鎖才起作用。
一個對象只有一個鎖。所以，如果一個線程獲得該鎖，就沒有其他線程可以獲得鎖，直到第一個線程釋放（或返回）鎖。這也意味著任何其他線程都不能進入該對象上的synchronized方法或代碼塊，直到該鎖被釋放。
釋放鎖是指持鎖線程退出了synchronized同步方法或代碼塊。
?
在使用同步代碼塊時候，應該指定在哪個對象上同步，也就是說要獲取哪個對象的鎖。例如：
? ??
public int fix(int y) {synchronized (this) {x = x - y;}return x;}當然，同步方法也可以改寫為非同步方法，但功能完全一樣的，例如： ??
public synchronized int getX() {return x++;}與
public int getX() {synchronized (this) {return x++;}}效果是完全一樣的。
要同步靜態方法，需要一個用于整個類對象的鎖，這個對象是就是這個類（XXX.class)。顯而易見，因為靜態方法、靜態變量都是與類綁定的，而不是與某個特定的對象綁定。
?例如：
public static synchronized int setName(String name){Xxx.name = name;}等價于
public static int setName(String name){synchronized(Xxx.class){Xxx.name = name;} }?如果線程試圖進入同步方法，而其鎖已經被占用，則線程在該對象上被阻塞。實質上，線程進入該對象的的一種鎖池中，必須在那里等待，直到其鎖被釋放，該線程再次變為可運行或運行為止。
當考慮阻塞時，一定要注意哪個對象正被用于鎖定：
1、調用同一個對象中非靜態同步方法的線程將彼此阻塞。如果是不同對象，則每個線程有自己的對象的鎖，線程間彼此互不干預。
2、調用同一個類中的靜態同步方法的線程將彼此阻塞，它們都是鎖定在相同的Class對象上。
3、靜態同步方法和非靜態同步方法將永遠不會彼此阻塞，因為靜態方法鎖定在Class對象上，非靜態方法鎖定在該類的對象上。
4、對于同步代碼塊，要看清楚什么對象已經用于鎖定（synchronized后面括號的內容）。在同一個對象上進行同步的線程將彼此阻塞，在不同對象上鎖定的線程將永遠不會彼此阻塞。
死鎖
死鎖對Java程序來說，是很復雜的，也很難發現問題。當兩個線程被阻塞，每個線程在等待另一個線程時就發生死鎖。
來看一個實例：
public class DeadlockRisk {private static class Resource {public int value;}private Resource resourceA =new Resource();private Resource resourceB =new Resource();public int read() {synchronized (resourceA) {synchronized (resourceB) {return resourceB.value +resourceA.value;}}}public void write(int a,int b) {synchronized (resourceB) {synchronized (resourceA) {resourceA.value = a;resourceB.value = b;}}} }假設read()方法由一個線程啟動，write()方法由另外一個線程啟動。讀線程將擁有resourceA鎖，寫線程將擁有resourceB鎖，兩者都堅持等待的話就出現死鎖。
實際上，上面這個例子發生死鎖的概率很小。因為在代碼內的某個點，CPU必須從讀線程切換到寫線程，所以，死鎖基本上不能發生。
就算我們費盡心機去寫一個故意死鎖的程序，也不見會發生死鎖。但是，無論代碼中發生死鎖的概率有多小，一旦發生死鎖，程序就死掉。
volatile關鍵字
在Java內存模型中，有main memory，每個線程也有自己的memory (例如寄存器)。為了性能，一個線程會在自己的memory中保持要訪問的變量的副本。這樣就會出現同一個變量在某個瞬間，在一個線程的memory中的值可能與另外一個線程memory中的值，或者main memory中的值不一致的情況。
一個變量聲明為volatile，就意味著這個變量是隨時會被其他線程修改的，因此不能將它cache在線程memory中
當我們使用volatile關鍵字去修飾變量的時候，所有線程都會直接讀取該變量并且不緩存它。這就確保了線程讀取到的變量是同內存中是一致的。
volatile可以用在任何變量前面，但不能用于final變量前面，因為final型的變量是禁止修改的。也不存在線程安全的問題。
Java 語言中的 volatile變量可以被看作是一種“程度較輕的 synchronized”；與 synchronized 塊相比，volatile 變量所需的編碼較少，并且運行時開銷也較少，但是它所能實現的功能也僅是 synchronized 的一部分。
之所以要單獨提出volatile這個不常用的關鍵字原因是這個關鍵字在高性能的多線程程序中也有很重要的用途，只是這個關鍵字用不好會出很多問題。
只能在有限的一些情形下使用volatile 變量替代鎖。要使 volatile 變量提供理想的線程安全，必須同時滿足下面兩個條件：
1、對變量的寫操作不依賴于當前值。
2、該變量沒有包含在具有其他變量的不變式中。
實際上，這些條件表明，可以被寫入volatile 變量的這些有效值獨立于任何程序的狀態，包括變量的當前狀態。
第一個條件的限制使 volatile 變量不能用作線程安全計數器。雖然增量操作（x++）看上去類似一個單獨操作，實際上它是一個由讀取－修改－寫入操作序列組成的組合操作，必須以原子方式執行，而volatile 不能提供必須的原子特性。實現正確的操作需要使 x的值在操作期間保持不變，而 volatile 變量無法實現這點。（然而，如果將值調整為只從單個線程寫入，那么可以忽略第一個條件。）
大多數編程情形都會與這兩個條件的其中之一沖突，使得 volatile 變量不能像 synchronized 那樣普遍適用于實現線程安全。
?
比如做了一個i++操作，計算機內部做了三次處理：讀取－修改－寫入。
同樣，對于一個long型數據，做了個賦值操作，在32位系統下需要經過兩步才能完成，先修改低32位，然后修改高32位。
假想一下，當將以上的操作放到一個多線程環境下操作時候，有可能出現的問題，是這些步驟執行了一部分，而另外一個線程就已經引用了變量值，這樣就導致了讀取臟數據的問題。
?
用volatile修飾的變量，線程在每次使用變量的時候，都會讀取變量修改后的最的值。volatile很容易被誤用，用來進行原子性操作。
??
下面看一個例子，我們實現一個計數器，每次線程啟動的時候，會調用計數器inc方法，對計數器進行加一。
public class Counter {public static int count = 0;public static void inc() {//這里延遲1毫秒，使得結果明顯try {Thread.sleep(1);} catch (InterruptedException e) {}count++;}public static void main(String[] args) {//同時啟動1000個線程，去進行i++計算，看看實際結果for (int i = 0; i < 1000; i++) {new Thread(new Runnable() {@Overridepublic void run() {Counter.inc();}}).start();}//這里每次運行的值都有可能不同,可能為1000System.out.println("運行結果:Counter.count="+ Counter.count);} }?運行結果:Counter.count=995
實際運算結果每次可能都不一樣，本機的結果為：運行結果:Counter.count=995，可以看出，在多線程的環境下，Counter.count并沒有期望結果是1000
很多人以為，這個是多線程并發問題，只需要在變量count之前加上volatile就可以避免這個問題，那我們在修改代碼看看，看看結果是不是符合我們的期望
public class Counter {public volatile static int count = 0;public static void inc() {//這里延遲1毫秒，使得結果明顯try {Thread.sleep(1);} catch (InterruptedException e) {}count++;}public static void main(String[] args) {//同時啟動1000個線程，去進行i++計算，看看實際結果for (int i = 0; i < 1000; i++) {new Thread(new Runnable() {@Overridepublic void run() {Counter.inc();}}).start();}//這里每次運行的值都有可能不同,可能為1000System.out.println("運行結果:Counter.count="+ Counter.count);} }運行結果:Counter.count=992
?
運行結果還是沒有我們期望的1000，下面我們分析一下原因。
jvm在運行時刻內存的分配，其中有一個內存區域是jvm虛擬機棧，每一個線程運行時都有一個線程棧，
線程棧保存了線程運行時候變量值信息。當線程訪問某一個對象時候值的時候，首先通過對象的引用找到對應在堆內存的變量的值，然后把堆內存變量的具體值load到線程本地內存中，建立一個變量副本，之后線程就不再和對象在堆內存變量值有任何關系，而是直接修改副本變量的值，在修改完之后的某一個時刻（線程退出之前），自動把線程變量副本的值回寫到對象在堆中變量。這樣在堆中的對象的值就產生變化了。下面一幅圖描述這些交互
read and load 從主存復制變量到當前工作內存
use andassign? 執行代碼，改變共享變量值
store and write 用工作內存數據刷新主存相關內容
其中use and assign 可以多次出現
但是這一些操作并不是原子性，也就是 在read load之后，如果主內存count變量發生修改之后，線程工作內存中的值由于已經加載，不會產生對應的變化，所以計算出來的結果會和預期不一樣
對于volatile修飾的變量，jvm虛擬機只是保證從主內存加載到線程工作內存的值是最新的。
例如假如線程1，線程2 在進行read,load 操作中，發現主內存中count的值都是5，那么都會加載這個最新的值。
在線程1堆count進行修改之后，會write到主內存中，主內存中的count變量就會變為6。
線程2由于已經進行read,load操作，在進行運算之后，也會更新主內存count的變量值為6。
導致兩個線程盡管使用了volatile關鍵字，還是會存在并發的情況。
?
總之，個人建議，volatile能不用就不用，非高手不能駕馭。
補充
1、對于同步，要時刻清醒在哪個對象上同步，這是關鍵。
2、每個對象只有一個鎖；當提到同步時，應該清楚在什么上同步，也就是說在哪個對象上同步。
3、不必同步類中所有的方法，類可以同時擁有同步和非同步方法。
4、如果兩個線程要執行一個類中的synchronized方法，并且兩個線程使用相同的實例來調用方法，那么一次只能有一個線程能夠執行方法，另一個需要等待，直到鎖被釋放。也就是說：如果一個線程在對象上獲得一個鎖，就沒有任何其他線程可以進入（該對象的）類中的任何一個同步方法。
5、如果線程擁有同步和非同步方法，則非同步方法可以被多個線程自由訪問而不受鎖的限制。
6、線程睡眠時，它所持的任何鎖都不會釋放。
7、線程可以獲得多個鎖。比如，在一個對象的同步方法里面調用另外一個對象的同步方法，則獲取了兩個對象的同步鎖。
8、同步損害并發性，應該盡可能縮小同步范圍。同步不但可以同步整個方法，還可以同步方法中一部分代碼塊。
9、synchronized關鍵字是不能繼承的，也就是說，基類的方法synchronizedf(){} 在繼承類中并不自動是synchronized f(){}，而是變成了f(){}。繼承類需要你顯式的指定它的某個方法為synchronized方法。
線程的交互
wait()、notify()與notifyAll()
這里所提到的交互指java.lang.Object的類的三個方法：
?void notify()
????????? 喚醒在此對象監視器上等待的單個線程。
?void notifyAll()
????????? 喚醒在此對象監視器上等待的所有線程。
?void wait()
????????? 導致當前的線程等待，直到其他線程調用此對象的 notify()方法或 notifyAll()方法。
當然，wait()還有另外兩個重載方法：
?void wait(long timeout)
????????? 導致當前的線程等待，直到其他線程調用此對象的 notify()方法或 notifyAll()方法，或者超過指定的時間量。
?void wait(long timeout, int nanos)
????????? 導致當前的線程等待，直到其他線程調用此對象的 notify()方法或 notifyAll()方法，或者其他某個線程中斷當前線程，或者已超過某個實際時間量。
以上這些方法是幫助線程傳遞線程關心的狀態。
來看一個實例：
?
//計算輸出其他線程鎖計算的數據 public class ThreadA {public static void main(String[] args) {ThreadB b = new ThreadB();//啟動計算線程b.start();//線程A擁有b對象上的鎖。線程為了調用wait()或notify()方法，該線程必須是那個對象鎖的擁有者synchronized (b) {try {System.out.println("等待對象b完成計算。。。");//當前線程A釋放對象b的鎖，放到對象b的等待隊列中，直到收到對象b發出notify()或者notifyAll()的信號。//注意，b.wait()并不是讓b等待，而是讓當前線程等待bb.wait();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("b對象計算的總和是："+ b.total);}} }//計算1+2+3 ...+100的和 public class ThreadB extends Thread {int total;public void run() {synchronized (this) {for (int i = 0; i < 101; i++) {total += i;}//（完成計算了）喚醒在此對象監視器上等待的單個線程，在本例中線程A被喚醒notify();}} }?多個線程在等待一個對象鎖時候使用notifyAll()
在多數情況下，最好通知等待某個對象的所有線程。如果這樣做，可以在對象上使用notifyAll()讓所有在此對象上等待的線程沖出等待區，返回到可運行狀態。
依照上面的例子再寫一個實例：
//計算1+2+3 ...+100的和 public class Calculator extends Thread {int total;public void run() {synchronized (this) {for (int i = 0; i < 101; i++) {total += i;}try {Thread.sleep(1000);} catch(InterruptedException e) {e.printStackTrace();}notifyAll();}} }public class TestThread extends Thread{private Calculator calculator;public TestThread(Calculator c){this.calculator = c;}public void run(){synchronized (calculator) {try {System.out.println(Thread.currentThread() + "等待計算結果。。。");calculator.wait();} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread() + "計算結果為："+ calculator.total);}}public static void main(String[] args) {Calculator c = new Calculator();TestThread threadA = new TestThread(c);TestThread threadB = new TestThread(c);TestThread threadC = new TestThread(c);threadA.start();threadB.start();threadC.start();c.start();}}?運行程序，打印結果如下：
Thread[Thread-1,5,main]等待計算結果。。。
Thread[Thread-3,5,main]等待計算結果。。。
Thread[Thread-2,5,main]等待計算結果。。。
Thread[Thread-2,5,main]計算結果為：5050
Thread[Thread-3,5,main]計算結果為：5050
Thread[Thread-1,5,main]計算結果為：5050
?
雖然與我們預期的結果一樣，但是這是一個有漏洞的程序。下面將做具體分析。
threadA.start();
threadB.start();
threadC.start();
c.start();
這四行代碼雖然有先后順序，但是我們一再強調，調用start()方法之后線程并不一定立刻執行，而是進入到就緒狀態，至于先執行哪個，后執行哪個，由線程調度器隨機決定，是不可預測的。
假如線程c先執行完畢，這時候threadA（或者threadB、threadC）還沒有執行，那么問題就出現了，threadA需要等待c發出的notifyAll()信號，但是c早已執行完畢，不可能在第二次執行notifyAll()函數，threadA就會永遠等下去。
因此，當等待的事件發生時，需要能夠檢查notifyAll()通知事件是否已經發生。
通常，解決上面問題的最佳方式是利用某種循環，該循環檢查某個條件表達式，只有當正在等待的事情還沒有發生的情況下，它才繼續等待。
當在對象上調用wait()方法時，執行該代碼的線程立即放棄它在對象上的鎖。然而調用notify()時，并不意味著這時線程會放棄其鎖。如果線程仍然在完成同步代碼，則線程在移出之前不會放棄鎖。因此，只要調用notify()并不意味著這時該鎖變得可用。
必須在同步環境內調用wait()、notify()、notifyAll()方法。只有在線程擁有該對象的鎖時，才能調用這三個方法。
wait()、notify()、notifyAll()都是Object的實例方法。與每個對象具有鎖一樣，每個對象可以有一個線程列表，他們等待來自該信號（通知）。線程通過執行對象上的wait()方法獲得這個等待列表。從那時候起，它不再執行任何其他指令，直到調用對象的notify()方法為止。如果多個線程在同一個對象上等待，則將只選擇一個線程（不保證以何種順序）繼續執行。如果沒有線程等待，則不采取任何特殊操作。
對比
初看wait()與notify()方法與 suspend()和resume()方法對沒有什么分別，但是事實上它們是截然不同的。區別的核心在于，前面敘述的所有方法，阻塞時都不會釋放占用的鎖（如果占用了的話），而這一對方法則相反。上述的核心區別導致了一系列的細節上的區別。
首先，前面敘述的所有方法都隸屬于Thread 類，但是這一對卻直接隸屬于 Object 類，也就是說，所有對象都擁有這一對方法。初看起來這十分不可思議，但是實際上卻是很自然的，因為這一對方法阻塞時要釋放占用的鎖，而鎖是任何對象都具有的，調用任意對象的 wait() 方法導致線程阻塞，并且該對象上的鎖被釋放。而調用任意對象的notify()方法則導致因調用該對象的 wait() 方法而阻塞的線程中隨機選擇的一個解除阻塞（但要等到獲得鎖后才真正可執行）。
其次，前面敘述的所有方法都可在任何位置調用，但是這一對方法卻必須在 synchronized 方法或塊中調用，理由也很簡單，只有在synchronized 方法或塊中當前線程才占有鎖，才有鎖可以釋放。同樣的道理，調用這一對方法的對象上的鎖必須為當前線程所擁有，這樣才有鎖可以釋放。因此，這一對方法調用必須放置在這樣的 synchronized 方法或塊中，該方法或塊的上鎖對象就是調用這一對方法的對象。若不滿足這一條件，則程序雖然仍能編譯，但在運行時會出現IllegalMonitorStateException 異常。
wait() 和 notify() 方法的上述特性決定了它們經常和synchronized 方法或塊一起使用，將它們和操作系統的進程間通信機制作一個比較就會發現它們的相似性：synchronized方法或塊提供了類似于操作系統原語的功能，它們的執行不會受到多線程機制的干擾，而這一對方法則相當于 block 和wakeup 原語（這一對方法均聲明為 synchronized）。它們的結合使得我們可以實現操作系統上一系列精妙的進程間通信的算法（如信號量算法），并用于解決各種復雜的線程間通信問題。
關于 wait() 和 notify() 方法最后再說明兩點：
第一：調用 notify() 方法導致解除阻塞的線程是從因調用該對象的 wait() 方法而阻塞的線程中隨機選取的，我們無法預料哪一個線程將會被選擇，所以編程時要特別小心，避免因這種不確定性而產生問題。
第二：除了 notify()，notifyAll() 也可起到類似作用，唯一的區別在于，調用 notifyAll() 方法將把因調用該對象的 wait() 方法而阻塞的所有線程一次性全部解除阻塞。當然，只有獲得鎖的那一個線程才能進入可執行狀態。
守護線程
守護線程是一類特殊的線程，它和普通線程的區別在于它并不是應用程序的核心部分，當一個應用程序的所有非守護線程終止運行時，即使仍然有守護線程在運行，應用程序也將終止，反之，只要有一個非守護線程在運行，應用程序就不會終止。守護線程一般被用于在后臺為其它線程提供服務。
可以通過調用方法 isDaemon() 來判斷一個線程是否是守護線程，也可以調用方法 setDaemon() 來將一個線程設為守護線程。該方法必須在啟動線程前調用。該方法首先調用該線程的 checkAccess方法，且不帶任何參數。這可能拋出 SecurityException（在當前線程中）。
守護線程使用的情況較少，但并非無用，舉例來說，JVM的垃圾回收、內存管理等線程都是守護線程。還有就是在做數據庫應用時候，使用的數據庫連接池，連接池本身也包含著很多后臺線程，監控連接個數、超時時間、狀態等等。
來看一個實例：
public class Test{public static void main(String[] args){Thread t1 = new MyCommon();Thread t2 = new Thread(new MyDaemon());t2.setDaemon(true); //設置為守護線程t2.start();t1.start();} }class MyCommon extends Thread {public void run() {for (int i = 0; i < 5; i++){System.out.println("線程1第" + i + "次執行！");try {Thread.sleep(7);} catch(InterruptedException e) {e.printStackTrace();}}} }class MyDaemon implements Runnable {public void run() {for (long i = 0; i <9999999L; i++) {System.out.println("后臺線程第" + i +"次執行！");try {Thread.sleep(7);} catch(InterruptedException e) {e.printStackTrace();}}} }打印結果：
后臺線程第0次執行！
線程1第0次執行！
線程1第1次執行！
后臺線程第1次執行！
后臺線程第2次執行！
線程1第2次執行！
線程1第3次執行！
后臺線程第3次執行！
線程1第4次執行！
后臺線程第4次執行！
后臺線程第5次執行！
后臺線程第6次執行！
后臺線程第7次執行！
?
從上面的執行結果可以看出，前臺線程是保證執行完畢的，后臺線程還沒有執行完畢就退出了。
實際上，JRE判斷程序是否執行結束的標準是所有的前臺執線程行完畢了，而不管后臺線程的狀態，因此，在使用后臺線程時候一定要注意這個問題。
線程組
線程組是一個 Java 特有的概念，在 Java 中，線程組是類ThreadGroup 的對象，每個線程都隸屬于唯一一個線程組，這個線程組在線程創建時指定并在線程的整個生命期內都不能更改。
可以通過調用包含 ThreadGroup 類型參數的 Thread 類構造函數來指定線程屬的線程組，若沒有指定，則線程缺省地隸屬于名為 system 的系統線程組。
在 Java 中，除了預建的系統線程組外，所有線程組都必須顯式創建。在 Java 中，除系統線程組外的每個線程組又隸屬于另一個線程組，可以在創建線程組時指定其所隸屬的線程組，若沒有指定，則缺省地隸屬于系統線程組。這樣，所有線程組組成了一棵以系統線程組為根的樹。
Java 允許我們對一個線程組中的所有線程同時進行操作，比如我們可以通過調用線程組的相應方法來設置其中所有線程的優先級，也可以啟動或阻塞其中的所有線程。
Java 的線程組機制的另一個重要作用是線程安全。線程組機制允許我們通過分組來區分有不同安全特性的線程，對不同組的線程進行不同的處理，還可以通過線程組的分層結構來支持不對等安全措施的采用。Java 的 ThreadGroup 類提供了大量的方法來方便我們對線程組樹中的每一個線程組以及線程組中的每一個線程進行操作。
轉載于:https://www.cnblogs.com/duadu/p/6335815.html
創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎總結
- 上一篇： 刚刚接触的LINQ
- 下一篇： clearfix清除浮动