1、synchronized

把程式碼塊宣告為synchronized，有兩個重要後果，通常是指該程式碼具有原子性（automicity）和可見性（visibility）。

原子性

原子性意味著某個時刻，只有一個執行緒能夠執行一段程式碼，這段程式碼通過一個monitor Object保護。從而防止多個執行緒在更新共享狀態時相互衝突。

可見性

可見性要對付記憶體快取和編譯器優化的各種反常行為。它必須確保釋放鎖之前對共享資料做出的更改對於隨後獲得該鎖的另一個執行緒是可見的。

作用：如果沒有同步機制提供這種可見性保證，執行緒看到的共享變數可能是修改前的值或不一致的值，這將引發許多嚴重問題。

原理：當物件獲取鎖時，它首先使自己的快取記憶體無效，這樣就可以保證直接從主記憶體中裝入變數。同樣，在物件釋放鎖之前，它會重新整理其快取記憶體 ，

強制使已做的任何更改都出現在主記憶體中。這樣，可以保證在同一個鎖上同步的兩個執行緒看到在synchronized塊內修改的變數的相同值。

一般來說，執行緒以某種不必讓其他執行緒立即可以看到的方式（不管這些執行緒在暫存器中、在處理器特定的快取中，還是通過指令重排或者其他編譯器優化），不受快取變數值的約束，但是如果開發人員使用了同步，那麼執行庫將確保某一執行緒對變數所做的更新先於對現有synchronized塊所進行的更新，當進入由同一監控器（lock）保護的另一個synchronized塊時，將立刻可以看到這些對變數所做的更新。

類似的規則也存在與volatile變數上————————volatile只保證可見性，不保證原子性。

需要同步的場景

可見性同步的基本規則是在以下情況中必須同步：

1.讀取上一次可能是由另一個執行緒寫入的變數
2.寫入下一次可能由另一個執行緒讀取的變數

一致性同步：當修改多個相關值時，你想要其他執行緒原子地看到這組更改——要麼看到全部更改，要麼什麼也看不到。

這適用於相關資料項（如粒子的位置和速率）和元資料項（如連結串列中包含的資料值和列表自身中的資料項的鏈）

但在某些情況中，不必用同步來將資料從一個執行緒傳遞到另一個，因為JVM已經隱含地為您執行同步。這些情況包括：

1.由靜態初始化器（在靜態欄位上或static{}塊中的初始化器）
2.初始化資料時
3.訪問final欄位時
4.在建立執行緒之前建立物件時
5.執行緒可以看見它將要處理的物件

synchronized的限制

synchronized有一些功能上的限制：

1.它無法中斷一個正在等候獲得鎖的執行緒
2.無法通過投票得到鎖，如果不想等下去，也就沒法得到鎖
3.同步還要求鎖的釋放只能在與獲得鎖所在的堆疊幀相同的堆疊幀中進行，多數情況下，這沒問題（而且與異常處理互動的很好），但是，確實存在一些非塊結構的鎖更合適的情況

2.ReentrantLock

Java.util.concurrent.lock的Lock框架是鎖定的一個抽象，它允許把鎖定的實現作為Java類，而不是作為語言的特性來實現。
這為Lock的多種實現留下了空間，各種實現可能有不同的排程演算法、效能特性或者鎖定語義。
ReentrantLock類實現了Lock，它擁有與synchronized相同的併發性和記憶體語義，但是添加了類似投票、定時鎖等候和可中斷鎖等候的一些特性。
它還提供了在激烈爭用情況下更佳的效能。即，當許多執行緒都想訪問共享資源時，JVM可以花更少的時間來排程執行緒，把更多的時間用在執行執行緒上。
注意：用synchronized修飾的方法或者語句塊在程式碼執行完之後鎖自動釋放，而Lock類需要手動釋放，所以為了保證鎖最終被釋放（發生異常情況時），要把互斥區放在try內，釋放鎖放在finally內！

3.讀寫鎖ReadWriteLock

與互斥鎖相比，讀-寫鎖定允許對共享資料進行更高級別的併發訪問。雖然一次只有一個執行緒（writer執行緒）可以修改共享資料，但在許多情況下，
任何數量的執行緒可以同時讀取共享資料（reader執行緒）
從理論上講，與互斥鎖相比，讀-寫鎖所允許的併發效能增強將帶來更大的效能提高。
只有在多處理器上並且只在訪問模式適用於共享資料時，才能實現併發性增強。
————例如，某個最初用資料填充並且之後不經常對其進行修改的Collection，因為經常對其進行搜尋（比如搜尋某種目錄），所以這樣的Collection是使用讀-寫鎖定的理想候選者。

4.執行緒間通訊Condition

Condition可以替代傳統的執行緒間通訊，用await()替換wait()，用signal()替換notify()，用signalAll()替換notifyAll()。

為什麼方法名不直接叫wait()/notify()/notifyAll()？因為Object的這幾個方法是final的，不可重寫！

傳統執行緒的通訊方式，Condition都可以實現。
Condition是被繫結到Lock上的，要建立一個Lock的Condition必須用newCondition()方法。
Condition的強大在於它可以為多個執行緒間建立不同的Condition。

package test.concurrent;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class BoundedBuffer {
     final Lock lock = new ReentrantLock();  //鎖物件
     final Condition notFull = lock.newCondition(); //寫執行緒鎖
    final Condition notEmpty = lock.newCondition();//讀執行緒鎖
    final Object[] items = new Object[100];   //快取佇列
    int putptr;                                 //寫索引
    int takeptr;                            //讀索引
    int count;                              //佇列中資料數目
    //寫
    public void put(Object x)throws InterruptedException{
        lock.lock();    //鎖定
        try{
            //若佇列已滿，則將 寫執行緒 放入阻塞佇列
            while(count == items.length){
                notFull.await();
            }
            //寫入佇列，並更新寫索引
            items[putptr] = x;
            if(++putptr == items.length)putptr=0;
            ++count;
            //喚醒 讀執行緒
            notEmpty.signal();
        }finally{
            lock.unlock();//解除鎖定
        }
    }
    //讀
    public Object take() throws InterruptedException{
        lock.lock();    //鎖定
        try{
            //若佇列為空，則將 讀執行緒 放入阻塞佇列
            while(count == 0){
                notEmpty.await();
            }
            //讀取佇列，並更新讀索引
            Object x = items[takeptr];
            if(++takeptr == items.length)takeptr = 0;
            --count;
            //喚醒 寫執行緒
            notFull.signal();
            return x;
        }finally{
            lock.unlock();//解除鎖定
        }
    }
}  

其實就是java.util.concurrent.ArrayBlockingQueue