java執行緒 同步與非同步 執行緒池
1）多執行緒併發時，多個執行緒同時請求同一個資源，必然導致此資源的資料不安全，A執行緒修改了B線
程的處理的資料，而B執行緒又修改了A執行緒處理的數理。顯然這是由於全域性資源造成的，有時為了解
決此問題，優先考慮使用區域性變數，退而求其次使用同步程式碼塊，出於這樣的安全考慮就必須犧牲
系統處理效能，加在多執行緒併發時資源掙奪最激烈的地方，這就實現了執行緒的同步機制
同步：A執行緒要請求某個資源，但是此資源正在被B執行緒使用中，因為同步機制存在，A執行緒請求
不到，怎麼辦，A執行緒只能等待下去
非同步：A執行緒要請求某個資源，但是此資源正在被B執行緒使用中，因為沒有同步機制存在，A執行緒
仍然請求的到，A執行緒無需等待
 
顯然，同步最最安全，最保險的。而非同步不安全，容易導致死鎖，這樣一個執行緒死掉就會導致整個
程序崩潰，但沒有同步機制的存在，效能會有所提升
 
java中實現多執行緒
1）繼承Thread,重寫裡面的run方法
2）實現runnable介面
 
Doug Lea比較推薦後者，第一，java沒有單繼承的限制第二，還可以隔離程式碼
 
執行緒池
要知道在計算機中任何資源的建立，包括執行緒，都需要消耗系統資源的。在WEB服務中，對於web服
務器的響應速度必須要儘可能的快，這就容不得每次在使用者提交請求按鈕後，再建立執行緒提供服務
。為了減少使用者的等待時間，執行緒必須預先建立，放線上程池中，執行緒池可以用HashTable這種數
據結構來實現，看了Apach HTTP伺服器的執行緒池的原始碼，用是就是HashTable,KEY用執行緒物件，
value 用ControlRunnable，ControlRunnable是執行緒池中唯一能幹活的執行緒，是它指派執行緒池中的
執行緒對外提供服務。
出於安全考慮，Apach HTTP伺服器的執行緒池它是同步的。聽說weblogic有非同步的實現方式，沒有研
究過，不敢確定
---------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------
一、關鍵字：
thread（執行緒）、thread-safe(執行緒安全)、intercurrent（併發的）
synchronized(同步的)、asynchronized(非同步的)、
volatile（易變的）、atomic（原子的）、share（共享）
二、總結背景：
一次讀寫共享檔案編寫，嚯，好傢伙，竟然揪出這些零碎而又是一路的知識點。於是乎，Google和
翻閱了《Java參考大全》、《Effective Java Second Edition》，特此總結一下供日後工作學習參
考。
三、概念：
1、 什麼時候必須同步？什麼叫同步？如何同步？
要跨執行緒維護正確的可見性，只要在幾個執行緒之間共享非 final 變數，就必須使用
synchronized（或 volatile）以確保一個執行緒可以看見另一個執行緒做的更改。
為了線上程之間進行可靠的通訊，也為了互斥訪問，同步是必須的。這歸因於java語言規範的記憶體
模型，它規定了：一個執行緒所做的變化何時以及如何變成對其它執行緒可見。
因為多執行緒將非同步行為引程序序，所以在需要同步時，必須有一種方法強制進行。例如：如果2個線
程想要通訊並且要共享一個複雜的資料結構，如連結串列，此時需要確保它們互不衝突，也就是必須阻
止B執行緒在A執行緒讀資料的過程中向連結串列裡面寫資料（A獲得了鎖，B必須等A釋放了該鎖）。
為了達到這個目的，java在一箇舊的的程序同步模型——監控器（Monitor）的基礎上實現了一個巧
妙的方案：監控器是一個控制機制，可以認為是一個很小的、只能容納一個執行緒的盒子，一旦一個
執行緒進入監控器，其它的執行緒必須等待，直到那個執行緒退出監控為止。通過這種方式，一個監控器
可以保證共享資源在同一時刻只可被一個執行緒使用。這種方式稱之為同步。（一旦一個執行緒進入一
個例項的任何同步方法，別的執行緒將不能進入該同一例項的其它同步方法，但是該例項的非同步方
法仍然能夠被呼叫）。
錯誤的理解：同步嘛，就是幾個執行緒可以同時進行訪問。
同步和多執行緒關係：沒多執行緒環境就不需要同步;有多執行緒環境也不一定需要同步。
鎖提供了兩種主要特性：互斥（mutual exclusion）和可見性（visibility）。
互斥即一次只允許一個執行緒持有某個特定的鎖，因此可使用該特性實現對共享資料的協調訪問協議
，這樣，一次就只有一個執行緒能夠使用該共享資料。
可見性要更加複雜一些，它必須確保釋放鎖之前對共享資料做出的更改對於隨後獲得該鎖的另一個
執行緒是可見的 —— 如果沒有同步機制提供的這種可見性保證，執行緒看到的共享變數可能是修改前
的值或不一致的值，這將引發許多嚴重問題
小結：為了防止多個執行緒併發對同一資料的修改，所以需要同步，否則會造成資料不一致（就是所
謂的：執行緒安全。如java集合框架中Hashtable和Vector是執行緒安全的。我們的大部分程式都不是線
程安全的，因為沒有進行同步，而且我們沒有必要，因為大部分情況根本沒有多執行緒環境）。
 
2、 什麼叫原子的（原子操作）？
Java原子操作是指：不會被打斷地的操作。（就是做到互斥和可見性？！）
那難道原子操作就可以真的達到執行緒安全同步效果了嗎？實際上有一些原子操作不一定是執行緒安全
的。
那麼，原子操作在什麼情況下不是執行緒安全的呢？也許是這個原因導致的：java執行緒允許執行緒在自
己的記憶體區儲存變數的副本。允許執行緒使用本地的私有拷貝進行工作而非每次都使用主存的值是為
了提高效能（本人愚見：雖然原子操作是執行緒安全的，可各執行緒在得到變數（讀操作）後，就是各
自玩弄自己的副本了，更新操作（寫操作）因未寫入主存中，導致其它執行緒不可見）。
那該如何解決呢？因此需要通過java同步機制。
在java中，32位或者更少位數的賦值是原子的。在一個32位的硬體平臺上，除了double和long
型的其它原始型別通常都是使用32位進行表示，而double和long通常使用64位表示。另外，物件引
用使用本機指標實現，通常也是32位的。對這些32位的型別的操作是原子的。
這些原始型別通常使用32位或者64位表示，這又引入了另一個小小的神話：原始型別的大小是
由語言保證的。這是不對的。java語言保證的是原始型別的表數範圍而非JVM中的儲存大小。因此，
int型總是有相同的表數範圍。在一個JVM上可能使用32位實現，而在另一個JVM上可能是64位的。在
此再次強調：在所有平臺上被保證的是表數範圍，32位以及更小的值的操作是原子的。
 
3、 不要搞混了：同步、非同步
舉個例子：普通B/S模式（同步）AJAX技術（非同步）
同步：提交請求->等待伺服器處理->處理完返回這個期間客戶端瀏覽器不能幹任何事
非同步：請求通過事件觸發->伺服器處理（這是瀏覽器仍然可以作其他事情）->處理完畢
可見，彼“同步”非此“同步”——我們說的java中的那個共享資料同步（synchronized）
一個同步的物件是指行為（動作），一個是同步的物件是指物質（共享資料）。
 
4、 Java同步機制有4種實現方式：（部分引用網上資源）
①    ThreadLocal ② synchronized( ) ③ wait() 與 notify() ④ volatile
目的：都是為了解決多執行緒中的對同一變數的訪問衝突
ThreadLocal
    ThreadLocal 保證不同執行緒擁有不同例項，相同執行緒一定擁有相同的例項，即為每一個使用該
變數的執行緒提供一個該變數值的副本，每一個執行緒都可以獨立改變自己的副本，而不是與其它執行緒
的副本衝突。
優勢：提供了執行緒安全的共享物件
與其它同步機制的區別：同步機制是為了同步多個執行緒對相同資源的併發訪問，是為了多個執行緒之
間進行通訊；而 ThreadLocal 是隔離多個執行緒的資料共享，從根本上就不在多個執行緒之間共享資源
，這樣當然不需要多個執行緒進行同步了。
volatile
     volatile 修飾的成員變數在每次被執行緒訪問時，都強迫從共享記憶體中重讀該成員變數的值。
而且，當成員變數發生變化時，強迫執行緒將變化值回寫到共享記憶體。
    優勢：這樣在任何時刻，兩個不同的執行緒總是看到某個成員變數的同一個值。
    緣由：Java 語言規範中指出，為了獲得最佳速度，允許執行緒儲存共享成員變數的私有拷貝，而
且只當執行緒進入或者離開同步程式碼塊時才與共享成員變數的原始值對比。這樣當多個執行緒同時與某
個物件互動時，就必須要注意到要讓執行緒及時的得到共享成員變數的變化。而 volatile 關鍵字就
是提示 VM ：對於這個成員變數不能儲存它的私有拷貝，而應直接與共享成員變數互動。
     使用技巧：在兩個或者更多的執行緒訪問的成員變數上使用 volatile 。當要訪問的變數已在
synchronized 程式碼塊中，或者為常量時，不必使用。
        執行緒為了提高效率，將某成員變數(如A)拷貝了一份（如B），執行緒中對A的訪問其實訪問的
是B。只在某些動作時才進行A和B的同步，因此存在A和B不一致的情況。volatile就是用來避免這種
情況的。 volatile告訴jvm，它所修飾的變數不保留拷貝，直接訪問主記憶體中的（讀操作多時使用
較好；執行緒間需要通訊，本條做不到）
Volatile 變數具有 synchronized 的可見性特性，但是不具備原子特性。這就是說執行緒能夠自
動發現 volatile 變數的最新值。Volatile 變數可用於提供執行緒安全，但是隻能應用於非常有限的
一組用例：多個變數之間或者某個變數的當前值與修改後值之間沒有約束。
您只能在有限的一些情形下使用 volatile 變數替代鎖。要使 volatile 變數提供理
想的執行緒安全，必須同時滿足下面兩個條件：
對變數的寫操作不依賴於當前值；該變數沒有包含在具有其他變數的不變式中。
 
sleep() vs wait()
sleep是執行緒類（Thread）的方法，導致此執行緒暫停執行指定時間，把執行機會給其他執行緒，但是監
控狀態依然保持，到時後會自動恢復。呼叫sleep不會釋放物件鎖。
wait是Object類的方法，對此物件呼叫wait方法導致本執行緒放棄物件鎖，進入等待此物件的等待鎖
定池，只有針對此物件發出notify方法（或notifyAll）後本執行緒才進入物件鎖定池準備獲得物件鎖
進入執行狀態。
（如果變數被宣告為volatile，在每次訪問時都會和主存一致；如果變數在同步方法或者同步塊中
被訪問，當在方法或者塊的入口處獲得鎖以及方法或者塊退出時釋放鎖時變數被同步。）
 
四、例子：
Demo1:
package test.thread;
 
 
class SynTest{
 
//非同步
static void method(Thread thread){
System.out.println("begin "+thread.getName());
try{
Thread.sleep(2000);
}catch(Exception ex){
ex.printStackTrace();
}
System.out.println("end "+thread.getName());
}
 
//同步方式一：同步方法
synchronized static void method1(Thread thread){//這個方法是同步的方法，每次只有一
個執行緒可以進來
System.out.println("begin "+thread.getName());
try{
Thread.sleep(2000);
}catch(Exception ex){
ex.printStackTrace();
}
System.out.println("end "+thread.getName());
}
 
//同步方式二：同步程式碼塊
static void method2(Thread thread){
synchronized(SynTest.class) {
System.out.println("begin "+thread.getName());
try{
Thread.sleep(2000);
}catch(Exception ex){
ex.printStackTrace();
}
System.out.println("end "+thread.getName());
}
}
 
 
//同步方式三：使用同步物件鎖
private static Object _lock1=new Object();
private static byte _lock2[]={};//據說，此鎖更可提高效能。源於：鎖的物件越小越好
static void method3(Thread thread){
synchronized(_lock1) {
System.out.println("begin "+thread.getName());
try{
Thread.sleep(2000);
}catch(Exception ex){
ex.printStackTrace();
}
System.out.println("end "+thread.getName());
}
}
 
public static void main(String[] args){
//啟動3個執行緒，這裡用了匿名類
for(int i=0;i<3;i++){
new Thread(){
public void run(){
method(this);
//method1(this);
//method2(this);
//method3(this);
}
}.start();
}
}
}
 
 
 
 
 
 
Demo2:
package test.thread;
 
import com.util.LogUtil;
 
 
public class SynTest2 {
 
public static void main(String[] args){
Callme target=new Callme();
Caller ob1=new Caller(target,"Hello");
Caller ob2=new Caller(target,"Synchronized");
Caller ob3=new Caller(target,"World");
}
}
 
class Callme{
 
 
synchronized void test(){
LogUtil.log("測試是否是：一旦一個執行緒進入一個例項的任何同步方法，別的執行緒將不能
進入該同一例項的其它同步方法，但是該例項的非同步方法仍然能夠被呼叫");
}
 
void nonsynCall(String msg){
LogUtil.log("["+msg);
LogUtil.log("]");
}
 
synchronized void synCall(String msg){
LogUtil.logPrint("["+msg);
LogUtil.log("]");
}
}
 
class Caller implements Runnable{
String msg;
Callme target;
Thread t;
 
Caller(Callme target,String msg){
this.target=target;
this.msg=msg;
t=new Thread(this);
t.start();
}
 
public void run() {
// TODO Auto-generated method stub
//target.nonsynCall(msg);
target.synCall(msg);
target.test();
}
 
 
}