[[284020]]

重入鎖

鎖作為并發共享數據，保證一致性的工具，在JAVA平臺有多種實現(如 synchronized(重量級) 和 ReentrantLock(輕量級)等等 ) 。這些已經寫好提供的鎖為我們開發提供了便利。

重入鎖，也叫做遞歸鎖，指的是同一線程 外層函數獲得鎖之后 ，內層遞歸函數仍然有獲取該鎖的代碼，但不受影響。

在JAVA環境下 ReentrantLock 和synchronized 都是 可重入鎖

public class Test implements Runnable { 
    public synchronized void get() { 
        System.out.println("name:" + Thread.currentThread().getName() + " get();"); 
        set(); 
    } 
    public synchronized void set() { 
        System.out.println("name:" + Thread.currentThread().getName() + " set();"); 
    } 
    @Override 
    public void run() { 
        get(); 
    } 
    public static void main(String[] args) { 
        Test ss = new Test(); 
        new Thread(ss).start(); 
        new Thread(ss).start(); 
        new Thread(ss).start(); 
        new Thread(ss).start(); 
    } 
} 
public class Test02 extends Thread { 
    ReentrantLock lock = new ReentrantLock(); 
    public void get() { 
        lock.lock(); 
        System.out.println(Thread.currentThread().getId()); 
        set(); 
        lock.unlock(); 
    } 
    public void set() { 
        lock.lock(); 
        System.out.println(Thread.currentThread().getId()); 
        lock.unlock(); 
    } 
    @Override 
    public void run() { 
        get(); 
    } 
    public static void main(String[] args) { 
        Test ss = new Test(); 
        new Thread(ss).start(); 
        new Thread(ss).start(); 
        new Thread(ss).start(); 
    } 
} 

讀寫鎖

相比Java中的鎖(Locks in Java)里Lock實現，讀寫鎖更復雜一些。假設你的程序中涉及到對一些共享資源的讀和寫操作，且寫操作沒有讀操作那么頻繁。在沒有寫操作的時候，兩個線程同時讀一個資源沒有任何問題，所以應該允許多個線程能在同時讀取共享資源。但是如果有一個線程想去寫這些共享資源，就不應該再有其它線程對該資源進行讀或寫(譯者注：也就是說：讀-讀能共存，讀-寫不能共存，寫-寫不能共存)。這就需要一個讀/寫鎖來解決這個問題。Java5在java.util.concurrent包中已經包含了讀寫鎖。盡管如此，我們還是應該了解其實現背后的原理。

public class Cache { 
    static Map<String, Object> map = new HashMap<String, Object>(); 
    static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock(); 
    static Lock r = rwl.readLock(); 
    static Lock w = rwl.writeLock(); 
    // 獲取一個key對應的value 
    public static final Object get(String key) { 
        r.lock(); 
        try { 
            System.out.println("正在做讀的操作,key:" + key + " 開始"); 
            Thread.sleep(100); 
            Object object = map.get(key); 
            System.out.println("正在做讀的操作,key:" + key + " 結束"); 
            System.out.println(); 
            return object; 
        } catch (InterruptedException e) { 
        } finally { 
            r.unlock(); 
        } 
        return key; 
    } 
    // 設置key對應的value，并返回舊有的value 
    public static final Object put(String key, Object value) { 
        w.lock(); 
        try { 
            System.out.println("正在做寫的操作,key:" + key + ",value:" + value + "開始."); 
            Thread.sleep(100); 
            Object object = map.put(key, value); 
            System.out.println("正在做寫的操作,key:" + key + ",value:" + value + "結束."); 
            System.out.println(); 
            return object; 
        } catch (InterruptedException e) { 
        } finally { 
            w.unlock(); 
        } 
        return value; 
    } 
    // 清空所有的內容 
    public static final void clear() { 
        w.lock(); 
        try { 
            map.clear(); 
        } finally { 
            w.unlock(); 
        } 
    } 
    public static void main(String[] args) { 
        new Thread(new Runnable() { 
            @Override 
            public void run() { 
                for (int i = 0; i < 10; i++) { 
                    Cache.put(i + "", i + ""); 
                } 
            } 
        }).start(); 
        new Thread(new Runnable() { 
            @Override 
            public void run() { 
                for (int i = 0; i < 10; i++) { 
                    Cache.get(i + ""); 
                } 
            } 
        }).start(); 
    } 
} 

悲觀鎖、樂觀鎖

樂觀鎖

總是認為不會產生并發問題，每次去取數據的時候總認為不會有其他線程對數據進行修改，因此不會上鎖，但是在更新時會判斷其他線程在這之前有沒有對數據進行修改，一般會使用版本號機制或CAS操作實現。

version方式：一般是在數據表中加上一個數據版本號version字段，表示數據被修改的次數，當數據被修改時，version值會加一。當線程A要更新數據值時，在讀取數據的同時也會讀取version值，在提交更新時，若剛才讀取到的version值為當前數據庫中的version值相等時才更新，否則重試更新操作，直到更新成功。

核心SQL語句

update table set x=x+1, version=version+1 where id=#{id} and version=#{version}; 

CAS操作方式：即compare and swap 或者 compare and set，涉及到三個操作數，數據所在的內存值，預期值，新值。當需要更新時，判斷當前內存值與之前取到的值是否相等，若相等，則用新值更新，若失敗則重試，一般情況下是一個自旋操作，即不斷的重試。

悲觀鎖

總是假設最壞的情況，每次取數據時都認為其他線程會修改，所以都會加鎖(讀鎖、寫鎖、行鎖等)，當其他線程想要訪問數據時，都需要阻塞掛起。可以依靠數據庫實現，如行鎖、讀鎖和寫鎖等，都是在操作之前加鎖，在Java中，synchronized的思想也是悲觀鎖。

原子類

java.util.concurrent.atomic包：原子類的小工具包，支持在單個變量上解除鎖的線程安全編程

原子變量類相當于一種泛化的 volatile 變量，能夠支持原子的和有條件的讀-改-寫操作。AtomicInteger 表示一個int類型的值，并提供了 get 和 set 方法，這些 Volatile 類型的int變量在讀取和寫入上有著相同的內存語義。它還提供了一個原子的 compareAndSet 方法(如果該方法成功執行，那么將實現與讀取/寫入一個 volatile 變量相同的內存效果)，以及原子的添加、遞增和遞減等方法。AtomicInteger 表面上非常像一個擴展的 Counter 類，但在發生競爭的情況下能提供更高的可伸縮性，因為它直接利用了硬件對并發的支持。

為什么會有原子類

CAS：Compare and Swap，即比較再交換。

jdk5增加了并發包java.util.concurrent.*,其下面的類使用CAS算法實現了區別于synchronouse同步鎖的一種樂觀鎖。JDK 5之前Java語言是靠synchronized關鍵字保證同步的，這是一種獨占鎖，也是是悲觀鎖。

如果同一個變量要被多個線程訪問，則可以使用該包中的類

AtomicBoolean

AtomicInteger

AtomicLong

AtomicReference

CAS無鎖模式

什么是CAS

CAS：Compare and Swap，即比較再交換。

jdk5增加了并發包java.util.concurrent.*,其下面的類使用CAS算法實現了區別于synchronouse同步鎖的一種樂觀鎖。JDK 5之前Java語言是靠synchronized關鍵字保證同步的，這是一種獨占鎖，也是是悲觀鎖。

CAS算法理解

(1)與鎖相比，使用比較交換(下文簡稱CAS)會使程序看起來更加復雜一些。但由于其非阻塞性，它對死鎖問題天生免疫，并且，線程間的相互影響也遠遠比基于鎖的方式要小。更為重要的是，使用無鎖的方式完全沒有鎖競爭帶來的系統開銷，也沒有線程間頻繁調度帶來的開銷，因此，它要比基于鎖的方式擁有更優越的性能。

(2)無鎖的好處：

第一，在高并發的情況下，它比有鎖的程序擁有更好的性能;

第二，它天生就是死鎖免疫的。

就憑借這兩個優勢，就值得我們冒險嘗試使用無鎖的并發。

(3)CAS算法的過程是這樣：它包含三個參數CAS(V,E,N): V表示要更新的變量，E表示預期值，N表示新值。僅當V值等于E值時，才會將V的值設為N，如果V值和E值不同，則說明已經有其他線程做了更新，則當前線程什么都不做。最后，CAS返回當前V的真實值。

(4)CAS操作是抱著樂觀的態度進行的，它總是認為自己可以成功完成操作。當多個線程同時使用CAS操作一個變量時，只有一個會勝出，并成功更新，其余均會失敗。失敗的線程不會被掛起，僅是被告知失敗，并且允許再次嘗試，當然也允許失敗的線程放棄操作。基于這樣的原理，CAS操作即使沒有鎖，也可以發現其他線程對當前線程的干擾，并進行恰當的處理。

(5)簡單地說，CAS需要你額外給出一個期望值，也就是你認為這個變量現在應該是什么樣子的。如果變量不是你想象的那樣，那說明它已經被別人修改過了。你就重新讀取，再次嘗試修改就好了。

(6)在硬件層面，大部分的現代處理器都已經支持原子化的CAS指令。在JDK 5.0以后，虛擬機便可以使用這個指令來實現并發操作和并發數據結構，并且，這種操作在虛擬機中可以說是無處不在。

常用原子類

Java中的原子操作類大致可以分為4類：原子更新基本類型、原子更新數組類型、原子更新引用類型、原子更新屬性類型。這些原子類中都是用了無鎖的概念，有的地方直接使用CAS操作的線程安全的類型。

AtomicBoolean

AtomicInteger

AtomicLong

AtomicReference

public class Test0001 implements Runnable { 
    private static Integer count = 1; 
    private static AtomicInteger atomic = new AtomicInteger(); 
    @Override 
    public void run() { 
        while (true) { 
            int count = getCountAtomic(); 
            System.out.println(count); 
            if (count >= 150) { 
                break; 
            } 
        } 
    } 
    public synchronized Integer getCount() { 
        try { 
            Thread.sleep(50); 
        } catch (Exception e) { 
            // TODO: handle exception 
        } 
        return count++; 
    } 
    public Integer getCountAtomic() { 
        try { 
            Thread.sleep(50); 
        } catch (Exception e) { 
            // TODO: handle exception 
        } 
        return atomic.incrementAndGet(); 
    } 
    public static void main(String[] args) { 
        Test0001 test0001 = new Test0001(); 
        Thread t1 = new Thread(test0001); 
        Thread t2 = new Thread(test0001); 
        t1.start(); 
        t2.start(); 
    } 
} 

CAS(樂觀鎖算法)的基本假設前提

CAS比較與交換的偽代碼可以表示為：

do{

備份舊數據;

基于舊數據構造新數據;

}while(!CAS( 內存地址，備份的舊數據，新數據 )

(上圖的解釋：CPU去更新一個值，但如果想改的值不再是原來的值，操作就失敗，因為很明顯，有其它操作先改變了這個值。)

就是指當兩者進行比較時，如果相等，則證明共享數據沒有被修改，替換成新值，然后繼續往下運行;如果不相等，說明共享數據已經被修改，放棄已經所做的操作，然后重新執行剛才的操作。容易看出 CAS 操作是基于共享數據不會被修改的假設，采用了類似于數據庫的 commit-retry 的模式。當同步沖突出現的機會很少時，這種假設能帶來較大的性能提升。

public final int getAndAddInt(Object o, long offset, int delta) { 
 int v; 
 do { 
 v = getIntVolatile(o, offset); 
 } while (!compareAndSwapInt(o, offset, v, v + delta)); 
 return v; 
 } 
/**  
     * Atomically increments by one the current value.  
     *  
     * @return the updated value  
     */  
    public final int incrementAndGet() {  
     for (;;) {  
     //獲取當前值  
     int current = get();  
     //設置期望值  
     int next = current + 1;  
     //調用Native方法compareAndSet，執行CAS操作  
     if (compareAndSet(current, next))  
     //成功后才會返回期望值，否則無線循環  
     return next;  
     }  
    }  

CAS缺點

CAS存在一個很明顯的問題，即ABA問題。

問題：如果變量V初次讀取的時候是A，并且在準備賦值的時候檢查到它仍然是A，那能說明它的值沒有被其他線程修改過了嗎?

如果在這段期間曾經被改成B，然后又改回A，那CAS操作就會誤認為它從來沒有被修改過。針對這種情況，java并發包中提供了一個帶有標記的原子引用類AtomicStampedReference，它可以通過控制變量值的版本來保證CAS的正確性。

分布式鎖

如果想在不同的jvm中保證數據同步，使用分布式鎖技術。

有數據庫實現、緩存實現、Zookeeper分布式鎖