1、什么是公平鎖？什么是非公平鎖？

• 公平鎖：是指多個線程按照申請鎖的順序來獲取鎖，也就是說按秩序排隊，先來后到。

• 非公平鎖：是指多個線程獲取鎖的順序并不是按照申請鎖的順序來的。就像排隊打飯，總有些高年級同學(xué)會插隊。在高并發(fā)情況下，有可能會造成優(yōu)先級反轉(zhuǎn)或者饑餓現(xiàn)象(優(yōu)先級反轉(zhuǎn)好理解，就是本來輪到排在隊頭那個人打飯了，但是突然一人插隊跑前面了，這就是優(yōu)先級反轉(zhuǎn)；如果一直有人插隊，那么僅管這個同學(xué)已經(jīng)排在隊頭了，但是還是一直沒吃上飯，這就是饑餓現(xiàn)象)。

2、兩者區(qū)別：
在并發(fā)環(huán)境中，每個線程獲取鎖時都會查看此鎖維護(hù)的等待隊列，如果為空，或者當(dāng)前線程是等待隊列的第一個，就占鎖，否則就加入到等待隊列中。而非公平鎖比較粗魯，上來就嘗試占鎖，如果占鎖失敗，就采用類似公平鎖的那種方式。非公平鎖性能比較好，吞吐量比較大。ReentrantLock實例化的時候可以傳入?yún)?shù)true或者false指定創(chuàng)建公平鎖還是非公平鎖，true是公平鎖，false是非公平鎖，不傳默認(rèn)是false。而synchronized也是非公平鎖。

1、什么是可重入鎖？
可重入鎖又叫遞歸鎖。指的是外層函數(shù)獲得鎖之后，它可以進(jìn)入它所同步著的所有代碼，即使內(nèi)層函數(shù)也被鎖住，，也無需重新獲取鎖。

1public synchronized void method1(){
2        method2();
3}
4public synchronized void method2(){
5
6}

method1是加了鎖的，method2也是加了鎖的，然后在method1里面調(diào)用method2。當(dāng)method1獲取了鎖之后，調(diào)用的method2雖然也是加了鎖的，但是不用重新獲取鎖了，這就叫可重入鎖。也就說，可以理解為method1和method2獲取到的鎖可以理解為同一把鎖。ReentrantLock和synchronized都是可重入鎖。可重入鎖最大的作用就是防止死鎖。

2、可重入鎖demo：

• 驗證synchronized是可重入鎖：

 1public class LockDemo {
 2    public synchronized void fun1(){
 3        System.out.println(Thread.currentThread().getId() + "執(zhí)行fun1方法");
 4        fun2();
 5    }
 6    public synchronized void fun2(){
 7        System.out.println(Thread.currentThread().getId() + "執(zhí)行fun2方法");
 8    }
 9
10    public static void main(String[] args){
11           LockDemo lockDemo = new LockDemo();
12           new Thread( () -> lockDemo.fun1()).start();
13    }
14}

看這段代碼，fun1一個同步方法，在里面輸出一句話，然后又調(diào)用了同步方法fun2。最后在main方法里面創(chuàng)建一個線程去執(zhí)行fun1方法。如果synchronized是可重入鎖，那么打印這兩個輸出語句的應(yīng)該是同一個線程。

• 驗證ReentrantLock是可重入鎖：

 1public class LockDemo {
 2    public  void fun1(){
 3        ReentrantLock lock = new ReentrantLock();
 4        lock.lock();
 5        try {
 6            System.out.println(Thread.currentThread().getName() + ": 執(zhí)行fun1方法");
 7            fun2();
 8        }finally {
 9            lock.unlock();
10        }
11    }
12    public  void fun2(){
13        ReentrantLock lock = new ReentrantLock();
14        lock.lock();
15        try {
16            System.out.println(Thread.currentThread().getName() + ": 執(zhí)行fun2方法");
17        }finally {
18            lock.unlock();
19        }
20    }
21
22    public static void main(String[] args){
23           LockDemo lockDemo = new LockDemo();
24           new Thread( () -> lockDemo.fun1()).start();
25    }
26}

這段代碼只不過把synchronized換成了lock鎖，運(yùn)行結(jié)果是一樣的。以上兩端代碼說明synchronized和ReentrantLock都是可重入鎖。

前面聊CAS的時候說到了它底層用的就是UnSafe類和自旋鎖。這里就詳細(xì)說一說自旋鎖。
1、什么是自旋鎖？
我們知道像synchronized和ReentrantLock鎖，當(dāng)這個線程沒有獲取到鎖的時候就是阻塞狀態(tài)。而自旋鎖就是采用循環(huán)的方式去嘗試獲取鎖，這樣的好處就是減少上下文切換的消耗，但是比較消耗CPU資源。再來看看原子包裝類的getAddIncrement方法：

1public final int getAndAddInt(Object var1, long var2, int var4) {
2        int var5;
3        do {
4            var5 = this.getIntVolatile(var1, var2);
5        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
6        return var5;
7 }

當(dāng)while條件不成立時，就會一直執(zhí)行do語句，所以很消耗CPU。

舉個生活中的例子再來說明一下什么是自旋鎖：小明同學(xué)遇到了個問題，跑到講臺邊上去問老師。可是這時候老師在打電話，沒辦法立即給小明解答。小明就站在邊上干等著。這是小明就處于阻塞狀態(tài)，做不了其他事。而自旋鎖就是，小明看到老師現(xiàn)在沒時間，就先回到座位上寫作業(yè)，過一會兒再上去看，老師還沒時間，小明又回去做其他事。就這樣不斷的嘗試，知道成功。

2、手寫自旋鎖：

 1public class MyLock {
 2    AtomicReference<Thread> atomicReference = new AtomicReference<>();
 3
 4    public void myLock() {
 5        Thread thread = Thread.currentThread();
 6        System.out.println(thread.getName() + ": come in");
 7        while (!atomicReference.compareAndSet(null, thread)) {
 8        }
 9    }
10
11    public void myUnlock() {
12        Thread thread = Thread.currentThread();
13        atomicReference.compareAndSet(thread, null);
14        System.out.println(thread.getName() + ": come out");
15    }
16}

分析一下這段代碼：這個類有一個成員變量，原子引用類型的Thread，關(guān)于原子引用，之前在CAS詳解一文中說到過。這個類還有兩個方法，一個是myLock加鎖方法，一個是myUnlock，釋放鎖的方法。

• myLock方法：首先獲取到當(dāng)前線程，然后比較并交換，看看當(dāng)前線程是不是null，如果是，就設(shè)置為當(dāng)前線程thread，此時操作結(jié)果就是true，取反后就是false，就不進(jìn)入循環(huán)。如果當(dāng)前線程不是null，那么操作結(jié)果取反后就是true，那么就會進(jìn)入循環(huán)，知道thread重新變回null為止。

• myUnlock方法：獲取到當(dāng)前線程，然后將其設(shè)置為null，這就相當(dāng)于釋放鎖。

用下面的代碼測試一下：

 1public static void main(String[] args) {
 2        MyLock myLock = new MyLock();
 3        new Thread(() -> {
 4            myLock.myLock();
 5            try {
 6                Thread.sleep(5000);
 7            } catch (InterruptedException e) {
 8                e.printStackTrace();
 9            }
10            myLock.myUnlock();
11        },"A").start();
12
13        try {
14            TimeUnit.SECONDS.sleep(1);
15        } catch (InterruptedException e) {
16            e.printStackTrace();
17        }
18        new Thread(() -> {
19            myLock.myLock();
20            myLock.myUnlock();
21        },"B").start();
22}

A線程進(jìn)去，發(fā)現(xiàn)當(dāng)前是thread是null，所以就將當(dāng)前線程指向自己。此時的當(dāng)前線程就是A，然后小睡5秒。在睡的過程中，B進(jìn)來了，發(fā)現(xiàn)當(dāng)前線程是A，所以進(jìn)入while循環(huán)，一直進(jìn)行compareAndSet。5秒中后，A線程釋放鎖，將當(dāng)前線程設(shè)置為了null，這時B發(fā)現(xiàn)當(dāng)前線程是null了，就將當(dāng)前線程設(shè)置為了B，最后B也釋放鎖，將當(dāng)前線程設(shè)置為null。如果把線程A的myUnlock方法注釋掉，那么線程B將一直在while循環(huán)中出不來，造成死循環(huán)。

1、什么是獨(dú)占鎖？什么是共享鎖？

• 獨(dú)占鎖：不管是讀操作還是寫操作，該鎖一次只能被一個線程持有。synchronized和ReentrantLock都是獨(dú)占鎖。

• 共享鎖：指該鎖可以被多個線程持有。

• ReentrantReadWriteLock的讀鎖是共享鎖，寫鎖是獨(dú)占鎖。這樣可以保證讀操作的并發(fā)性。讀&讀可以共享鎖，讀&寫不能共存，寫&寫也不能共存。

下面看一段代碼：

 1public class MyCache {
 2    private volatile Map<String, Object> map = new HashMap<>();
 3
 4    public void put(String key, Object value){
 5        System.out.println(Thread.currentThread().getName() + ": 正在寫入： "+ value );
 6        map.put(key, value);
 7        System.out.println(Thread.currentThread().getName() + "：寫入完成");
 8    }
 9
10    public void get(String key){
11        System.out.println(Thread.currentThread().getName() + ": 正在讀取");
12        Object result = map.get(key);
13        System.out.println(Thread.currentThread().getName() + ": 讀取完成： " + result);
14    }
15}

這段代碼就是模擬一個緩存，用HashMap存數(shù)據(jù)?，F(xiàn)在創(chuàng)建5個線程去寫，5個線程去讀，看看情況如何。

 1public static void main(String[] args){
 2        MyCache myCache = new MyCache();
 3        for (int i=0; i<5; i++){
 4            final Integer temp = i;
 5            new Thread(() -> myCache.put(temp+"", temp),temp +"號線程").start();
 6        }
 7
 8        for (int i=0; i<5; i++){
 9            final Integer temp = i;
10            new Thread(() -> myCache.get(temp+""),temp +"號線程").start();
11        }
12}

看運(yùn)行結(jié)果：

可以看到，0號線程還沒寫入完成，2號線程進(jìn)來了，2號線程還沒完成，3號線程又進(jìn)來了。這就沒有保證寫操作是獨(dú)占的，沒有保證寫操作的原子性。看看使用ReentrantReadWriteLock如何解決：

 1public class MyCache {
 2    private volatile Map<String, Object> map = new HashMap<>();
 3    ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
 4    public void put(String key, Object value){
 5        lock.writeLock().lock();
 6        System.out.println(Thread.currentThread().getName() + ": 正在寫入： "+ value );
 7        map.put(key, value);
 8        System.out.println(Thread.currentThread().getName() + "：寫入完成");
 9        lock.writeLock().unlock();
10    }
11
12    public void get(String key){
13        lock.readLock().lock();
14        System.out.println(Thread.currentThread().getName() + ": 正在讀取");
15        Object result = map.get(key);
16        System.out.println(Thread.currentThread().getName() + ": 讀取完成： " + result);
17        lock.readLock().unlock();
18    }
19}

只需要在寫操作那里加寫鎖，在讀操作那里加讀鎖，這樣既可以保證數(shù)據(jù)的正確性，也提高了并發(fā)能力?？催\(yùn)行結(jié)果：

可以看到，寫操作的時候，保證了每次寫操作的原子性，是獨(dú)占鎖；讀的時候可以多個線程同時訪問，是共享鎖。

說起鎖，好像有很多很多種，其實無外乎synchronized、ReentrantLock、ReentrantReadWriteLock和 自旋鎖。其他的都是從不同角度對這幾種鎖進(jìn)行分類而已。

• synchronized: 是非公平鎖、可重入鎖、獨(dú)占鎖；

• ReentrantLock：默認(rèn)非公平鎖，在構(gòu)造方法中可傳入true變成公平鎖；是可重入鎖，也是獨(dú)占鎖；

• ReentrantReadWriteLock：讀鎖是共享鎖，寫鎖是獨(dú)占鎖；

• 自旋鎖：通過CAS實現(xiàn)的一種鎖。

END