線程狀態圖
線程共包括以下5種狀態。
1. 新建狀態(New) : 線程對像被創建後，就進入了新建狀態。例如，Thread thread = new Thread()。
2. 就緒狀態(Runnable): 也被稱為“可執行狀態”。線程對像被創建後，其它線程調用了該對象的start()方法，從而來啟動該線程。例如，thread.start()。處於就緒狀態的線程，隨時可能被CPU調度執行。
3. 運行狀態(Running) : 線程獲取CPU權限進行執行。需要注意的是，線程只能從就緒狀態進入到運行狀態。
4. 阻塞狀態(Blocked) : 阻塞狀態是線程因為某種原因放棄CPU使用權，暫時停止運行。直到線程進入就緒狀態，才有機會轉到運行狀態。阻塞的情況分三種：
(01) 等待阻塞-- 通過調用線程的wait()方法，讓線程等待某工作的完成。
(02) 同步阻塞-- 線程在獲取synchronized同步鎖失敗(因為鎖被其它線程所佔用)，它會進入同步阻塞狀態。
(03) 其他阻塞-- 通過調用線程的sleep()或join()或發出了I/O請求時，線程會進入到阻塞狀態。當sleep()狀態超時、join()等待線程終止或者超時、或者I/O處理完畢時，線程重新轉入就緒狀態。
5. 死亡狀態(Dead) : 線程執行完了或者因異常退出了run()方法，該線程結束生命週期。
實現多線程的方式Thread和Runnable
Thread:繼承thread類，實現run方法，在main函數中調用start方法啟動線程
Runnable：接口，實現Runnable接口，作為參數傳遞給Thread的構造函數，在main中調用start方法
例子：
class task implements Runnable { private int ticket = 10; @Override public void run() { for (int i = 0; i < 20; i++) { if (this.ticket > 0) { System.out.println(Thread.currentThread().getName() + " sold ticket " + this.ticket--); } } } }; public class RunnableTest { public static void main(String[]args){ task mytask = new task(); Thread t1 = new Thread(mytask); Thread t2 = new Thread(mytask); Thread t3 = new Thread(mytask); t1.start(); t2.start(); t3.start(); } }//ThreadTest.java 源碼class MyThread extends Thread { private int ticket = 10; public void run() { for (int i = 0; i < 20; i++) { if (this.ticket > 0) { System.out.println(this.getName() + " 賣票：ticket" + this.ticket--); } } }} public class ThreadTest { public static void main(String[] args) { // 啟動3個線程t1,t2,t3；每個線程各賣10張票！ MyThread t1 = new MyThread(); MyThread t2 = new MyThread(); MyThread t3 = new MyThread(); t1.start(); t2.start(); t3.start(); }};
Thread與Runnable的區別
Thread 是類，而Runnable是接口；Thread本身是實現了Runnable接口的類。我們知道“一個類只能有一個父類，但是卻能實現多個接口”，因此Runnable具有更好的擴展性。此外，Runnable還可以用於“資源的共享”。即，多個線程都是基於某一個Runnable對象建立的，它們會共享Runnable對像上的資源。通常，建議通過“Runnable”實現多線程！
Thread的run與start
start() : 它的作用是啟動一個新線程，新線程會執行相應的run()方法。 start()不能被重複調用。 start()實際上是通過本地方法start0()啟動線程的。而start0()會新運行一個線程，新線程會調用run()方法。
run() : run()就和普通的成員方法一樣，可以被重複調用。單獨調用run()的話，會在當前線程中執行run()，而並不會啟動新線程！ run()就是直接調用Thread線程的Runnable成員的run()方法，並不會新建一個線程。
// Demo.java 的源碼class MyThread extends Thread{ public MyThread(String name) { super(name); } public void run(){ System.out.println(Thread.currentThread().getName()+" is running"); } }; public class Demo { public static void main(String[] args) { Thread mythread=new MyThread("mythread"); System.out.println(Thread.currentThread().getName()+" call mythread.run()"); mythread.run(); System.out.println(Thread.currentThread().getName()+" call mythread.start()"); mythread.start(); } }輸出：
main call mythread.run()main is runningmain call mythread.start()mythread is running
synchronized
在java中每個對像都有一個同步鎖，當我們調用對象的synchronized方法就獲取了對象鎖，synchronized(obj)就獲取了“obj這個對象”的同步鎖.不同線程對同步鎖的訪問是互斥的.某時間點對象的同步鎖只能被一個線程獲取到.通過同步鎖，我們就能在多線程中，實現對“對象/方法”的互斥訪問. 例如，現在有兩個線程A和線程B，它們都會訪問“對象obj的同步鎖”。假設，在某一時刻，線程A獲取到“obj的同步鎖”並在執行一些操作；而此時，線程B也企圖獲取“obj的同步鎖” ―― 線程B會獲取失敗，它必須等待，直到線程A釋放了“該對象的同步鎖”之後線程B才能獲取到“obj的同步鎖”從而才可以運行。
基本規則
第一條: 當一個線程訪問“某對象”的“synchronized方法”或者“synchronized代碼塊”時，其他線程對“該對象”的該“synchronized方法”或者“synchronized代碼塊”的訪問將被阻塞。
第二條: 當一個線程訪問“某對象”的“synchronized方法”或者“synchronized代碼塊”時，其他線程仍然可以訪問“該對象”的非同步代碼塊。
第三條: 當一個線程訪問“某對象”的“synchronized方法”或者“synchronized代碼塊”時，其他線程對“該對象”的其他的“synchronized方法”或者“synchronized代碼塊”的訪問將被阻塞。
synchronized 方法
public synchronized void foo1() { System.out.println("synchronized methoed");}synchronized代碼塊public void foo2() { synchronized (this) { System.out.println("synchronized methoed"); }}synchronized代碼塊中的this是指當前對象。也可以將this替換成其他對象，例如將this替換成obj，則foo2()在執行synchronized(obj)時就獲取的是obj的同步鎖。
synchronized代碼塊可以更精確的控制衝突限制訪問區域，有時候表現更高效率
實例鎖和全局鎖
實例鎖-- 鎖在某一個實例對像上。如果該類是單例，那麼該鎖也具有全局鎖的概念。實例鎖對應的就是synchronized關鍵字。
全局鎖-- 該鎖針對的是類，無論實例多少個對象，那麼線程都共享該鎖。全局鎖對應的就是static synchronized（或者是鎖在該類的class或者classloader對像上）。
pulbic class Something { public synchronized void isSyncA(){} public synchronized void isSyncB(){} public static synchronized void cSyncA(){} public static synchronized void cSyncB(){}}
(01) x.isSyncA()與x.isSyncB() 不能被同時訪問。因為isSyncA()和isSyncB()都是訪問同一個對象(對象x)的同步鎖！
(02) x.isSyncA()與y.isSyncA() 可以同時被訪問。因為訪問的不是同一個對象的同步鎖，x.isSyncA()訪問的是x的同步鎖，而y.isSyncA()訪問的是y的同步鎖。
(03) x.cSyncA()與y.cSyncB()不能被同時訪問。因為cSyncA()和cSyncB()都是static類型，x.cSyncA()相當於Something.isSyncA()，y.cSyncB()相當於Something.isSyncB()，因此它們共用一個同步鎖，不能被同時反問。
(04) x.isSyncA()與Something.cSyncA() 可以被同時訪問。因為isSyncA()是實例方法，x.isSyncA()使用的是對象x的鎖；而cSyncA()是靜態方法，Something.cSyncA()可以理解對使用的是“類的鎖”。因此，它們是可以被同時訪問的。
線程阻塞與喚醒wait，notify，notifyAll
在Object.java中，定義了wait(), notify()和notifyAll()等接口。 wait()的作用是讓當前線程進入等待狀態，同時，wait()也會讓當前線程釋放它所持有的鎖。而notify()和notifyAll()的作用，則是喚醒當前對像上的等待線程；notify()是喚醒單個線程，而notifyAll()是喚醒所有的線程。
Object類中關於等待/喚醒的API詳細信息如下：
notify() -- 喚醒在此對象監視器上等待的單個線程。
notifyAll() -- 喚醒在此對象監視器上等待的所有線程。
wait() -- 讓當前線程處於“等待(阻塞)狀態”，“直到其他線程調用此對象的notify() 方法或notifyAll() 方法”，當前線程被喚醒(進入“就緒狀態”)。
wait(long timeout) -- 讓當前線程處於“等待(阻塞)狀態”，“直到其他線程調用此對象的notify() 方法或notifyAll() 方法，或者超過指定的時間量”，當前線程被喚醒(進入“就緒狀態”)。
wait(long timeout, int nanos) -- 讓當前線程處於“等待(阻塞)狀態”，“直到其他線程調用此對象的notify() 方法或notifyAll() 方法，或者其他某個線程中斷當前線程，或者已超過某個實際時間量”，當前線程被喚醒(進入“就緒狀態”)。
// WaitTest.java的源碼class ThreadA extends Thread{ public ThreadA(String name) { super(name); } public void run() { synchronized (this) { System.out.println(Thread.currentThread().getName()+" call notify()"); // 喚醒當前的wait線程notify(); } }} public class WaitTest { public static void main(String[] args) { ThreadA t1 = new ThreadA("t1"); synchronized(t1) { try { // 啟動“線程t1” System.out.println(Thread.currentThread().getName()+" start t1"); t1.start(); // 主線程等待t1通過notify()喚醒。 System.out.println(Thread.currentThread().getName()+" wait()"); t1.wait(); System.out.println(Thread.currentThread().getName()+" continue"); } catch (InterruptedException e) { e.printStackTrace(); } } }}輸出
main start t1main wait()t1 call notify()main continue
(01) 注意，圖中"主線程" 代表“主線程main”。 "線程t1" 代表WaitTest中啟動的“線程t1”。 而“鎖” 代表“t1這個對象的同步鎖”。
(02) “主線程”通過new ThreadA("t1") 新建“線程t1”。隨後通過synchronized(t1)獲取“t1對象的同步鎖”。然後調用t1.start()啟動“線程t1”。
(03) “主線程”執行t1.wait() 釋放“t1對象的鎖”並且進入“等待(阻塞)狀態”。等待t1對像上的線程通過notify() 或notifyAll()將其喚醒。
(04) “線程t1”運行之後，通過synchronized(this)獲取“當前對象的鎖”；接著調用notify()喚醒“當前對像上的等待線程”，也就是喚醒“主線程”。
(05) “線程t1”運行完畢之後，釋放“當前對象的鎖”。緊接著，“主線程”獲取“t1對象的鎖”，然後接著運行。
t1.wait()是通過“線程t1”調用的wait()方法，但是調用t1.wait()的地方是在“主線程main”中。而主線程必須是“當前線程”，也就是運行狀態，才可以執行t1.wait()。所以，此時的“當前線程”是“主線程main”！因此，t1.wait()是讓“主線程”等待，而不是“線程t1”！
package thread.Test; public class NotifyAllTest { private static Object obj = new Object(); public static void main(String[] args) { ThreadA t1 = new ThreadA("t1"); ThreadA t2 = new ThreadA("t2"); ThreadA t3 = new ThreadA("t3"); t1.start(); t2.start(); t3.start(); try { System.out.println(Thread.currentThread().getName()+" sleep(3000)"); Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized(obj) { System.out.println(Thread.currentThread().getName()+" notifyAll()"); obj.notifyAll();//在此喚醒t1.t2.t3 } } static class ThreadA extends Thread{ public ThreadA(String name){ super(name); } public void run() { synchronized (obj) { try { // 打印輸出結果System.out.println(Thread.currentThread().getName() + " wait"); //釋放obj對象鎖obj.wait(); // 打印輸出結果System.out.println(Thread.currentThread().getName() + " continue"); } catch (InterruptedException e) { e.printStackTrace(); } } } }}輸出：
t1 waitmain sleep(3000)t3 waitt2 waitmain notifyAll()t2 continuet3 continuet1 continue
(01) 主線程中新建並且啟動了3個線程"t1", "t2"和"t3"。
(02) 主線程通過sleep(3000)休眠3秒。在主線程休眠3秒的過程中，我們假設"t1", "t2"和"t3"這3個線程都運行了。以"t1"為例，當它運行的時候，它會執行obj.wait()等待其它線程通過notify()或額nofityAll()來喚醒它；相同的道理，"t2"和"t3"也會等待其它線程通過nofity()或nofityAll()來喚醒它們。
(03) 主線程休眠3秒之後，接著運行。執行obj.notifyAll() 喚醒obj上的等待線程，即喚醒"t1", "t2"和"t3"這3個線程。 緊接著，主線程的synchronized(obj)運行完畢之後，主線程釋放“obj鎖”。這樣，"t1", "t2"和"t3"就可以獲取“obj鎖”而繼續運行了！
notify，notifyall與鎖的關係
Object中的wait(), notify()等函數，和synchronized一樣，會對“對象的同步鎖”進行操作。
wait()會使“當前線程”等待，因為線程進入等待狀態，所以線程應該釋放它鎖持有的“同步鎖”，否則其它線程獲取不到該“同步鎖”而無法運行！
OK，線程調用wait()之後，會釋放它鎖持有的“同步鎖”；而且，根據前面的介紹，我們知道：等待線程可以被notify()或notifyAll()喚醒。現在，請思考一個問題：notify()是依據什麼喚醒等待線程的？或者說，wait()等待線程和notify()之間是通過什麼關聯起來的？答案是：依據“對象的同步鎖”。
負責喚醒等待線程的那個線程(我們稱為“喚醒線程”)，它只有在獲取“該對象的同步鎖”(這裡的同步鎖必須和等待線程的同步鎖是同一個)，並且調用notify()或notifyAll()方法之後，才能喚醒等待線程。雖然，等待線程被喚醒；但是，它不能立刻執行，因為喚醒線程還持有“該對象的同步鎖”。必須等到喚醒線程釋放了“對象的同步鎖”之後，等待線程才能獲取到“對象的同步鎖”進而繼續運行。
總之，notify(), wait()依賴於“同步鎖”，而“同步鎖”是對象鎖持有，並且每個對像有且僅有一個！這就是為什麼notify(), wait()等函數定義在Object類，而不是Thread類中的原因。
線程讓步yield
線程讓步，使線程從執行狀態變為就緒狀態，從而讓其它具有相同優先級的等待線程獲取執行權；但是，並不能保證在當前線程調用yield()之後，其它具有相同優先級的線程就一定能獲得執行權；也有可能是當前線程又進入到“運行狀態”繼續運行。
yield 與wait
(01) wait()是讓線程由“運行狀態”進入到“等待(阻塞)狀態”，而不yield()是讓線程由“運行狀態”進入到“就緒狀態”。
(02) wait()是會線程釋放它所持有對象的同步鎖，而yield()方法不會釋放鎖。
(03) wait是object的方法，yield是Thread的方法
線程休眠sleep
sleep() 的作用是讓當前線程休眠，即當前線程會從“運行狀態”進入到“休眠(阻塞)狀態”。 sleep()會指定休眠時間，線程休眠的時間會大於/等於該休眠時間；在線程重新被喚醒時，它會由“阻塞狀態”變成“就緒狀態”，從而等待cpu的調度執行。
sleep與wait的區別
wait()的作用是讓當前線程由“運行狀態”進入“等待(阻塞)狀態”的同時，也會釋放同步鎖。而sleep()的作用是也是讓當前線程由“運行狀態”進入到“休眠(阻塞)狀態。（這個其實區別不大）
wait()會釋放對象的同步鎖，而sleep()則不會釋放鎖
wait是object的方法，sleep是Thread的方法
join
讓主線程等待，子線程運行完畢，主線程才能繼續運行
interrupt
用來終止處於阻塞狀態的線程
@Overridepublic void run() { try { while (true) { // 執行任務... } } catch (InterruptedException ie) { // 由於產生InterruptedException異常，退出while(true)循環，線程終止！ }}在while(true)中不斷的執行任務，當線程處於阻塞狀態時，調用線程的interrupt()產生InterruptedException中斷。中斷的捕獲在while(true)之外，這樣就退出了while(true)循環
終止處於運行狀態的線程
@Overridepublic void run() { while (!isInterrupted()) { // 執行任務... }}通用的終止線程的方式
@Overridepublic void run() { try { // 1. isInterrupted()保證，只要中斷標記為true就終止線程。 while (!isInterrupted()) { // 執行任務... } } catch (InterruptedException ie) { // 2. InterruptedException異常保證，當InterruptedException異常產生時，線程被終止。 }}
線程優先級
java 中的線程優先級的範圍是1～10，默認的優先級是5。 “高優先級線程”會優先於“低優先級線程”執行。 java 中有兩種線程：用戶線程和守護線程。可以通過isDaemon()方法來區別它們：如果返回false，則說明該線程是“用戶線程”；否則就是“守護線程”。用戶線程一般用戶執行用戶級任務，而守護線程也就是“後台線程”，一般用來執行後台任務。需要注意的是：Java虛擬機在“用戶線程”都結束後會後退出。
每個線程都有一個優先級。 “高優先級線程”會優先於“低優先級線程”執行。每個線程都可以被標記為一個守護進程或非守護進程。在一些運行的主線程中創建新的子線程時，子線程的優先級被設置為等於“創建它的主線程的優先級”，當且僅當“創建它的主線程是守護線程”時“子線程才會是守護線程”。
當Java虛擬機啟動時，通常有一個單一的非守護線程（該線程通過是通過main()方法啟動）。 JVM會一直運行直到下面的任意一個條件發生，JVM就會終止運行：
(01) 調用了exit()方法，並且exit()有權限被正常執行。
(02) 所有的“非守護線程”都死了(即JVM中僅僅只有“守護線程”)。
守護進程
(01) 主線程main是用戶線程，它創建的子線程t1也是用戶線程。
(02) t2是守護線程。在“主線程main”和“子線程t1”(它們都是用戶線程)執行完畢，只剩t2這個守護線程的時候，JVM自動退出。
生產者消費者問題
(01) 生產者僅僅在倉儲未滿時候生產，倉滿則停止生產。
(02) 消費者僅僅在倉儲有產品時候才能消費，倉空則等待。
(03) 當消費者發現倉儲沒產品可消費時候會通知生產者生產。
(04) 生產者在生產出可消費產品時候，應該通知等待的消費者去消費。
線程之間的通信
方式：共享內存和消息傳遞
共享內存：線程A和線程B共享內存，線程A更新共享變量的值，刷新到主內存中，線程B去主內存中讀取線程A更新後的變量。整個通信過程必須通過主內存。同步是顯式進行的。
如果一個變量是volatile類型，則對該變量的讀寫就將具有原子性。如果是多個volatile操作或類似於volatile++這種複合操作，這些操作整體上不具有原子性。
volatile變量自身俱有下列特性：
[可見性]：對一個volatile變量的讀，總是能看到（任意線程）對這個volatile變量最後的寫入。
[原子性]：對任意單個volatile變量的讀/寫具有原子性，但類似於volatile++這種複合操作不具有原子性。
volatile寫：當寫一個volatile變量時，JMM會把該線程對應的本地內存中的共享變量刷新到主內存。
volatile讀：當讀一個volatile變量時，JMM會把該線程對應的本地內存置為無效。線程接下來將從主內存中讀取共享變量。
消息傳遞：消息的發送在消息的接受之前，同步隱式進行。
ThreadLocal
ThreadLocal 不是用來解決共享對象的多線程訪問問題的，一般情況下，通過ThreadLocal.set() 到線程中的對像是該線程自己使用的對象，其他線程是不需要訪問的，也訪問不到的.ThreadLocal使得各線程能夠保持各自獨立的一個對象，並不是通過ThreadLocal.set()來實現的，而是通過每個線程中的new 對象的操作來創建的對象，每個線程創建一個，不是什麼對象的拷貝或副本。通過ThreadLocal.set()將這個新創建的對象的引用保存到各線程的自己的一個map中，每個線程都有這樣一個map，執行ThreadLocal.get()時，各線程從自己的map中取出放進去的對象，因此取出來的是各自自己線程中的對象，ThreadLocal實例是作為map的key來使用的。 如果ThreadLocal.set()進去的東西本來就是多個線程共享的同一個對象，那麼多個線程的ThreadLocal.get()取得的還是這個共享對象本身，還是有並發訪問問題。
ThreadLocal的一個實現
import java.util.Collections; import java.util.HashMap; import java.util.Map; /** * 使用了ThreadLocal的類* * @author leizhimin 2010-1-5 10:35:27 */ public class MyThreadLocal { //定義了一個ThreadLocal變量，用來保存int或Integer數據private com.lavasoft.test2.ThreadLocal<Integer> tl = new com.lavasoft.test2.ThreadLocal<Integer>() { @Override protected Integer initialValue() { return 0; } }; public Integer getNextNum() { //將tl的值獲取後加1，並更新設置t1的值tl.set(tl.get() + 1); return tl.get(); } } class ThreadLocal<T> { private Map<Thread, T> map = Collections.synchronizedMap(new HashMap<Thread, T>()); public ThreadLocal() { } protected T initialValue() { return null; } public T get() { Thread t = Thread.currentThread(); T obj = map.get(t); if (obj == null && !map.containsKey(t)) { obj = initialValue(); map.put(t, obj); } return obj; } public void set(T value) { map.put(Thread.currentThread(), value); } public void remove() { map.remove(Thread.currentThread()); } }事實上ThreadLocal是這樣做的：
public T get() { Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) { ThreadLocalMap.Entry e = map.getEntry(this); if (e != null) return (T)e.value; } return setInitialValue(); }