多線程使用的主要目的在於：
1、吞吐量：你做WEB，容器幫你做了多線程，但是他只能幫你做請求層面的。簡單的說，可能就是一個請求一個線程。或多個請求一個線程。如果是單線程，那同時只能處理一個用戶的請求。
2、伸縮性：也就是說，你可以通過增加CPU核數來提升性能。如果是單線程，那程序執行到死也就利用了單核，肯定沒辦法通過增加CPU核數來提升性能。鑒於你是做WEB的，第1點可能你幾乎不涉及。那這里我就講第二點吧。--舉個簡單的例子：假設有個請求，這個請求服務端的處理需要執行3個很緩慢的IO操作（比如數據庫查詢或文件查詢），那么正常的順序可能是（括號里面代表執行時間）：
a、讀取文件1 （10ms）
b、處理1的數據（1ms）
c、讀取文件2 （10ms）
d、處理2的數據（1ms）
e、讀取文件3 （10ms）
f、處理3的數據（1ms）
g、整合1、2、3的數據結果 （1ms）
單線程總共就需要34ms。
那如果你在這個請求內，把ab、cd、ef分別分給3個線程去做，就只需要12ms了。
所以多線程不是沒怎么用，而是，你平常要善於發現一些可優化的點。然后評估方案是否應該使用。假設還是上面那個相同的問題：但是每個步驟的執行時間不一樣了。
a、讀取文件1 （1ms）
b、處理1的數據（1ms）
c、讀取文件2 （1ms）
d、處理2的數據（1ms）
e、讀取文件3 （28ms）
f、處理3的數據（1ms）
g、整合1、2、3的數據結果 （1ms）單線程總共就需要34ms。
如果還是按上面的划分方案（上面方案和木桶原理一樣，耗時取決於最慢的那個線程的執行速度），在這個例子中是第三個線程，執行29ms。那么最后這個請求耗時是30ms。比起不用單線程，就節省了4ms。但是有可能線程調度切換也要花費個1、2ms。
因此，這個方案顯得優勢就不明顯了，還帶來程序復雜度提升。不太值得。那么現在優化的點，就不是第一個例子那樣的任務分割多線程完成。而是優化文件3的讀取速度。可能是采用緩存和減少一些重復讀取。首先，假設有一種情況，所有用戶都請求這個請求，那其實相當於所有用戶都需要讀取文件3。
那你想想，100個人進行了這個請求，相當於你花在讀取這個文件上的時間就是28×100=2800ms了。那么，如果你把文件緩存起來，那只要第一個用戶的請求讀取了，第二個用戶不需要讀取了，從內存取是很快速的，可能1ms都不到。偽代碼：
看起來好像還不錯，建立一個文件名和文件數據的映射。如果讀取一個map中已經存在的數據，那么就不不用讀取文件了。可是問題在於，Servlet是並發，上面會導致一個很嚴重的問題，死循環。因為，HashMap在並發修改的時候，可能是導致循環鏈表的構成！！！（具體你可以自行閱讀HashMap源碼）如果你沒接觸過多線程，可能到時候發現服務器沒請求也巨卡，也不知道什么情況！好的，那就用ConcurrentHashMap，正如他的名字一樣，他是一個線程安全的HashMap，這樣能輕松解決問題。
這樣真的解決問題了嗎，這樣雖然只要有用戶訪問過文件a，那另一個用戶想訪問文件a，也會從fileName2Data中拿數據，然后也不會引起死循環。可是，如果你覺得這樣就已經完了，那你把多線程也想的太簡單了，騷年！你會發現，1000個用戶首次訪問同一個文件的時候，居然讀取了1000次文件（這是最極端的，可能只有幾百）。What the fuckin hell!!!難道代碼錯了嗎，難道我就這樣過我的一生！好好分析下。Servlet是多線程的，那么
上面注釋的“偶然”，這是完全有可能的，因此，這樣做還是有問題。因此，可以自己簡單的封裝一個任務來處理。
以上所有代碼都是直接在bbs打出來的，不保證可以直接運行。
多線程最多的場景：web服務器本身；各種專用服務器（如游戲服務器）；多線程的常見應用場景：
1、后台任務，例如：定時向大量（100w以上）的用戶發送郵件；
2、異步處理，例如：發微博、記錄日志等；
3、分布式計算
======================================================================
在java中，每一個線程有一塊工作內存區，其中存放着被所有線程共享的主內存中的變量的值的拷貝。當線程執行時，它在自己的工作內存中操作這些變量。
為了存取一個共享的變量，一個線程通常先獲取鎖定並且清除它的工作內存區，這保證該共享變量從所有線程的共享內存區正確地裝入到線程的工作內存區，當線程解鎖時保證該工作內存區中變量的值協會到共享內存中。
當一個線程使用某一個變量時，不論程序是否正確地使用線程同步操作，它獲取的值一定是由它本身或者其他線程存儲到變量中的值。例如，如果兩個線程把不同的值或者對象引用存儲到同一個共享變量中，那么該變量的值要么是這個線程的，要么是那個線程的，共享變量的值不會是由兩個線程的引用值組合而成。
一個變量時Java程序可以存取的一個地址，它不僅包括基本類型變量、引用類型變量，而且還包括數組類型變量。保存在主內存區的變量可以被所有線程共享，但是一個線程存取另一個線程的參數或者局部變量時不可能的，所以開發人員不必擔心局部變量的線程安全問題。
volatile變量–多線程間可見
由於每個線程都有自己的工作內存區，因此當一個線程改變自己的工作內存中的數據時，對其他線程來說，可能是不可見的。為此，可以使用volatile關鍵字破事所有線程軍讀寫內存中的變量，從而使得volatile變量在多線程間可見。
聲明為volatile的變量可以做到如下保證：
1、其他線程對變量的修改，可以及時反應在當前線程中；2、確保當前線程對volatile變量的修改，能及時寫回到共享內存中，並被其他線程所見；3、使用volatile聲明的變量，編譯器會保證其有序性。
同步關鍵字synchronized
同步關鍵字synchronized是Java語言中最為常用的同步方法之一。在JDK早期版本中，synchronized的性能並不是太好，值適合於鎖競爭不是特別激烈的場合。在JDK6中，synchronized和非公平鎖的差距已經縮小。更為重要的是，synchronized更為簡潔明了，代碼可讀性和維護性比較好。
鎖定一個對象的方法：
當method()方法被調用時，調用線程首先必須獲得當前對象所，若當前對象鎖被其他線程持有，這調用線程會等待，犯法結束后，對象鎖會被釋放，以上方法等價於下面的寫法：
其次，使用synchronized還可以構造同步塊，與同步方法相比，同步塊可以更為精確控制同步代碼范圍。一個小的同步代碼非常有離與鎖的快進快出，從而使系統擁有更高的吞吐量。
synchronized也可以用於static函數：
這個地方一定要注意，synchronized的鎖是加在當前Class對象上，因此，所有對該方法的調用，都必須獲得Class對象的鎖。
雖然synchronized可以保證對象或者代碼段的線程安全，但是僅使用synchronized還是不足以控制擁有復雜邏輯的線程交互。為了實現多線程間的交互，還需要使用Object對象的wait()和notify()方法。
典型用法：
在使用wait()方法前，需要獲得對象鎖。在wait()方法執行時，當前線程或釋放obj的獨占鎖，供其他線程使用。
當等待在obj上線程收到obj.notify()時，它就能重新獲得obj的獨占鎖，並繼續運行。注意了，notify()方法是隨機喚起等待在當前對象的某一個線程。
下面是一個阻塞隊列的實現：
synchronized配合wait()、notify()應該是Java開發者必須掌握的基本技能。
Reentrantlock重入鎖
Reentrantlock稱為重入鎖。它比synchronized擁有更加強大的功能，它可以中斷、可定時。在高並發的情況下，它比synchronized有明顯的性能優勢。
Reentrantlock提供了公平和非公平兩種鎖。公平鎖是對鎖的獲取是先進先出，而非公平鎖是可以插隊的。當然從性能上分析，非公平鎖的性能要好得多。因此，在無特殊需要，應該優選非公平鎖，但是synchronized提供鎖業不是絕對公平的。Reentrantlock在構造的時候可以指定鎖是否公平。
在使用重入鎖時，一定要在程序最后釋放鎖。一般釋放鎖的代碼要寫在finally里。否則，如果程序出現異常，Loack就永遠無法釋放了。synchronized的鎖是JVM最后自動釋放的。
經典使用方式如下：
Reentrantlock提供了非常豐富的鎖控制功能，靈活應用這些控制方法，可以提高應用程序的性能。不過這里並非是極力推薦使用Reentrantlock。重入鎖算是JDK中提供的高級開發工具。
ReadWriteLock讀寫鎖
讀寫分離是一種非常常見的數據處理思想。在sql中應該算是必須用到的技術。ReadWriteLock是在JDK5中提供的讀寫分離鎖。讀寫分離鎖可以有效地幫助減少鎖競爭，以提升系統性能。讀寫分離使用場景主要是如果在系統中，讀操作次數遠遠大於寫操作。使用方式如下：
Condition對象
Conditiond對象用於協調多線程間的復雜協作。主要與鎖相關聯。通過Lock接口中的newCondition()方法可以生成一個與Lock綁定的Condition實例。Condition對象和鎖的關系就如用Object.wait()、Object.notify()兩個函數以及synchronized關鍵字一樣。
這里可以把ArrayBlockingQueue的源碼摘出來看一下：
此實例簡單實現了一個對象池，對象池最大容量為100。因此，當同時有100個對象請求時，對象池就會出現資源短缺，未能獲得資源的線程就需要等待。當某個線程使用對象完畢后，就需要將對象返回給對象池。此時，由於可用資源增加，因此，可以激活一個等待該資源的線程。
ThreadLocal線程局部變量
在剛開始接觸ThreadLocal，筆者很難理解這個線程局部變量的使用場景。當現在回過頭去看，ThreadLocal是一種多線程間並發訪問變量的解決方案。與synchronized等加鎖的方式不同，ThreadLocal完全不提供鎖，而使用了以空間換時間的手段，為每個線程提供變量的獨立副本，以保障線程安全，因此它不是一種數據共享的解決方案。
ThreadLocal是解決線程安全問題一個很好的思路，ThreadLocal類中有一個Map，用於存儲每一個線程的變量副本，Map中元素的鍵為線程對象，而值對應線程的變量副本，由於Key值不可重復，每一個“線程對象”對應線程的“變量副本”，而到達了線程安全。
特別值得注意的地方，從性能上說，ThreadLocal並不具有絕對的又是，在並發量不是很高時，也行加鎖的性能會更好。但作為一套與鎖完全無關的線程安全解決方案，在高並發量或者所競爭激烈的場合，使用ThreadLocal可以在一定程度上減少鎖競爭。
下面是一個ThreadLocal的簡單使用：
輸出結果：
輸出的結果信息可以發現每個線程所產生的序號雖然都共享同一個TestNum實例，但它們並沒有發生相互干擾的情況，而是各自產生獨立的序列號，這是因為ThreadLocal為每一個線程提供了單獨的副本。
鎖的性能和優化
“鎖”是最常用的同步方法之一。在平常開發中，經常能看到很多同學直接把鎖加很大一段代碼上。還有的同學只會用一種鎖方式解決所有共享問題。顯然這樣的編碼是讓人無法接受的。特別的在高並發的環境下，激烈的鎖競爭會導致程序的性能下降德更加明顯。因此合理使用鎖對程序的性能直接相關。
1、線程的開銷
在多核情況下，使用多線程可以明顯提高系統的性能。但是在實際情況中，使用多線程的方式會額外增加系統的開銷。相對於單核系統任務本身的資源消耗外，多線程應用還需要維護額外多線程特有的信息。比如，線程本身的元數據，線程調度，線程上下文的切換等。
2、減小鎖持有時間
在使用鎖進行並發控制的程序中，當鎖發生競爭時，單個線程對鎖的持有時間與系統性能有着直接的關系。如果線程持有鎖的時間很長，那么相對地，鎖的競爭程度也就越激烈。因此，在程序開發過程中，應該盡可能地減少對某個鎖的占有時間，以減少線程間互斥的可能。比如下面這一段代碼：
此實例如果只有mutexMethod()方法是有同步需要的，而在beforeMethod(),和afterMethod()並不需要做同步控制。如果beforeMethod(),和afterMethod()分別是重量級的方法，則會花費較長的CPU時間。在這個時候，如果並發量較大時，使用這種同步方案會導致等待線程大量增加。因為當前執行的線程只有在執行完所有任務后，才會釋放鎖。
下面是優化后的方案，只在必要的時候進行同步，這樣就能明顯減少線程持有鎖的時間，提高系統的吞吐量。代碼如下：
3、減少鎖粒度
減小鎖粒度也是一種削弱多線程鎖競爭的一種有效手段，這種技術典型的使用場景就是ConcurrentHashMap這個類。在普通的HashMap中每當對集合進行add()操作或者get()操作時，總是獲得集合對象的鎖。這種操作完全是一種同步行為，因為鎖是在整個集合對象上的，因此，在高並發時，激烈的鎖競爭會影響到系統的吞吐量。
如果看過源碼的同學應該知道HashMap是數組+鏈表的方式做實現的。ConcurrentHashMap在HashMap的基礎上將整個HashMap分成若干個段(Segment)，每個段都是一個子HashMap。如果需要在增加一個新的表項，並不是將這個HashMap加鎖，二十搜線根據hashcode得到該表項應該被存放在哪個段中，然后對該段加鎖，並完成put()操作。這樣，在多線程環境中，如果多個線程同時進行寫入操作，只要被寫入的項不存在同一個段中，那么線程間便可以做到真正的並行。具體的實現希望讀者自己花點時間讀一讀ConcurrentHashMap這個類的源碼，這里就不再做過多描述了。
4、鎖分離
在前面提起過ReadWriteLock讀寫鎖，那么讀寫分離的延伸就是鎖的分離。同樣可以在JDK中找到鎖分離的源碼LinkedBlockingQueue。
這里需要說明一下的就是，take()和put()函數是相互獨立的，它們之間不存在鎖競爭關系。只需要在take()和put()各自方法內部分別對takeLock和putLock發生競爭。從而，削弱了鎖競爭的可能性。
5、鎖粗化
上面說到的減小鎖時間和粒度，這樣做就是為了滿足每個線程持有鎖的時間盡量短。但是，在粒度上應該把握一個度，如果對用一個鎖不停地進行請求、同步和釋放，其本身也會消耗系統寶貴的資源，反而加大了系統開銷。
我們需要知道的是，虛擬機在遇到一連串連續的對同一鎖不斷進行請求和釋放的操作時，便會把所有的鎖操作整合成對鎖的一次請求，從而減少對鎖的請求同步次數，這樣的操作叫做鎖的粗化。下面是一段整合實例演示：
JVM整合后的形式：
因此，這樣的整合給我們開發人員對鎖粒度的把握給出了很好的演示作用。
無鎖的並行計算
上面花了很大篇幅在說鎖的事情，同時也提到過鎖是會帶來一定的上下文切換的額外資源開銷，在高並發時，”鎖“的激烈競爭可能會成為系統瓶頸。因此，這里可以使用一種非阻塞同步方法。這種無鎖方式依然能保證數據和程序在高並發環境下保持多線程間的一致性。
1、非阻塞同步/無鎖非阻塞同步方式其實在前面的ThreadLocal中已經有所體現，每個線程擁有各自獨立的變量副本，因此在並行計算時，無需相互等待。這里筆者主要推薦一種更為重要的、基於比較並交換（Compare And Swap）CAS算法的無鎖並發控制方法。
CAS算法的過程：它包含3個參數CAS(V,E,N)。V表示要更新的變量，E表示預期值，N表示新值。僅當V值等於E值時，才會將V的值設為N，如果V值和E值不同，則說明已經有其他線程做了更新，則當前線程什么都不做。最后CAS返回當前V的真實值。CAS操作時抱着樂觀的態度進行的，它總是認為自己可以成功完成操作。當多個線程同時使用CAS操作一個變量時，只有一個會勝出，並成功更新，其余俊輝失敗。失敗的線程不會被掛起，僅是被告知失敗，並且允許再次嘗試，當然也允許失敗的線程放棄操作。基於這樣的原理，CAS操作及時沒有鎖，也可以發現其他線程對當前線程的干擾，並且進行恰當的處理。
2、原子量操作
JDK的java.util.concurrent.atomic包提供了使用無鎖算法實現的原子操作類，代碼內部主要使用了底層native代碼的實現。有興趣的同學可以繼續跟蹤一下native層面的代碼。這里就不貼表層的代碼實現了。
下面主要以一個例子來展示普通同步方法和無鎖同步的性能差距：
測試結果如下：
相信這樣的測試結果將內部鎖和非阻塞同步算法的性能差異體現的非常明顯。因此筆者更推薦直接視同atomic下的這個原子類