前言：上一節(jié)講述了鎖的原理，這節(jié)先講解鎖的應(yīng)用，再通過上節(jié)的原理來實(shí)現(xiàn)一個(gè)自定義的鎖。
1 從鎖開始講起
1.1 lock
在java.util.concurrent.locks.Lock.java中的源碼解釋：
根據(jù)Lock接口的源碼注釋，Lock接口的實(shí)現(xiàn)，具備和同步關(guān)鍵字同樣的內(nèi)存語義。
lock的常用API
lock.lock(); // 如果一個(gè)線程拿到鎖，其他線程會(huì)等待
lock.tryLock(); // 嘗試獲取鎖，獲取不到立即返回
lock.tryLock(1000L); // 嘗試獲取鎖1秒，獲取不到也立即返回
1.1.1 可重入鎖ReentrantLock
package szu.vander.lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author : Vander
* @date : 2019/12/7
* @description : 可重入鎖
*/
public class ReentrantDemo {
private final static ReentrantLock reentrantLock = new ReentrantLock();
public static void main(String[] args){
reentrantLock.lock();
try {
System.out.println("第1次獲取鎖");
System.out.println("this thread lock hold count : " + reentrantLock.getHoldCount());
reentrantLock.lock();
System.out.println("第2次獲取鎖");
System.out.println("this thread lock hold count : " + reentrantLock.getHoldCount());
} finally {
reentrantLock.unlock();
reentrantLock.unlock();
}
System.out.println("this thread lock hold count : " + reentrantLock.getHoldCount());
new Thread(() -> {
System.out.println(Thread.currentThread() + ": expect to get the lock！");
reentrantLock.lock();
System.out.println(Thread.currentThread() + ": had get the lock！");
}).start();
}
}
運(yùn)行結(jié)果
這里說明一下ReentrantLock有公平和非公平之分。（公平鎖就是哪個(gè)線程等得久就讓哪個(gè)線程先執(zhí)行）
1.1.2 可響應(yīng)中斷的ReentrantLock
package concurrent.lock;
import java.time.Instant;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author : Vander
* @date : 2019/12/8
* @description : 獲取鎖后可被中斷
*/
public class LockInterruptiblyDemo {
private Lock lock = new ReentrantLock();
public static void main(String[] args) {
LockInterruptiblyDemo lockInterruptiblyDemo = new LockInterruptiblyDemo();
Runnable runnable = () -> {
try {
lockInterruptiblyDemo.getLockAndInterrupt();
} catch (InterruptedException e) {
Instant now = Instant.now();
System.out.println(String.format("%s - %s : in the main runnable func, being interrupt, %s"
, now
, Thread.currentThread()
, e.toString()));
}
};
Thread thread0 = new Thread(runnable);
Thread thread1 = new Thread(runnable);
try {
thread0.start();
Thread.sleep(500); // 等待0.5秒，讓thread0先執(zhí)行
thread1.start();
Thread.sleep(2000); // 兩秒后，中斷thread1
thread1.interrupt(); // 處于Sleep狀態(tài)或處于lockInterruptibly狀態(tài)能被中斷
} catch (InterruptedException e) {
Instant now = Instant.now();
System.out.println(String.format("%s - %s : in the main func, being interrupt, %s"
, now
, Thread.currentThread()
, e.toString()));
}
}
public void getLockAndInterrupt() throws InterruptedException {
Instant now = Instant.now();
System.out.println(String.format("%s - %s : expect the this lock", now, Thread.currentThread()));
lock.lockInterruptibly();// 阻塞,能立即響應(yīng)中斷，lock.lock()，阻塞且不立即響應(yīng)中斷
try {
now = Instant.now();
System.out.println(String.format("%s - %s : get the this lock" +
", and start sleep 10s", now, Thread.currentThread()));
TimeUnit.SECONDS.sleep(10);
} catch (InterruptedException e) {
now = Instant.now();
System.out.println(String.format("%s - %s : in the getLockAndInterrupt func, being interrupt, %s"
, now
, Thread.currentThread()
, e.toString()));
} finally {
now = Instant.now();
System.out.println(String.format("%s - %s : run into finally", now, Thread.currentThread()));
lock.unlock();
System.out.println(String.format("%s - %s : release the this lock", now, Thread.currentThread()));
}
}
}
運(yùn)行結(jié)果：線程0獲得了鎖，并處于Sleep狀態(tài)，線程1進(jìn)入阻塞并且能響應(yīng)中斷的狀態(tài)，將線程1中斷，線程1可以響應(yīng)中斷。
2）改為lock.lock()
運(yùn)行結(jié)果：改成lock()之后，線程1就不立即響應(yīng)中斷了，它會(huì)一直等鎖，然后進(jìn)入Sleep的時(shí)候才發(fā)現(xiàn)中斷狀態(tài)為已經(jīng)被改變了，才去響應(yīng)中斷
1.1.3 讀寫鎖（ReadWriteLock）
為了提高讀操作比寫操作多的場景的性能，設(shè)計(jì)出了讀寫鎖的思路。當(dāng)某個(gè)線程進(jìn)行寫操作時(shí)，所以進(jìn)行讀操作的線程都不能來讀，因?yàn)檫@樣有可能會(huì)讀取到臟數(shù)據(jù)；另一種情況是，如果某個(gè)線程僅僅是來讀數(shù)據(jù)的，總不能讓其它讀數(shù)據(jù)的線程不能來讀吧，所以這種情況下的讀鎖是可以共享的，屬于共享鎖。而第一種情況的寫數(shù)據(jù)時(shí)，鎖是互斥的，屬于互斥鎖，也稱為獨(dú)享鎖。
設(shè)計(jì)思路：維護(hù)一對(duì)關(guān)聯(lián)鎖，一個(gè)用于只讀操作，一個(gè)用于寫入操作；
讀鎖可以由多個(gè)讀線程同時(shí)持有，而寫鎖是排他的，互斥的。
示例場景
緩存組件、集合的并發(fā)線程安全性改造。
鎖降級(jí)(解決讀取兩次數(shù)據(jù)的數(shù)據(jù)不一致問題)
寫鎖是線程獨(dú)占，讀鎖是共享，所以寫->讀是降級(jí)。（讀->寫，是不能實(shí)現(xiàn)的，因?yàn)槌钟凶x鎖的情況下，是不能再持有寫鎖的）
在讀寫鎖中還會(huì)提到的概念是鎖降級(jí)指的是寫鎖降級(jí)成為讀鎖。持有當(dāng)前擁有的寫鎖的同時(shí)，再獲取到讀鎖，隨后釋放寫鎖的過程。
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* @author : Vander
* @date : 2019/12/8
* @description : 這里既是讀寫鎖的一種常見應(yīng)用，也是鎖降級(jí)的常用之處
*/
public class CacheDataDemo<T> {
/**
* hashMap不是線程安全的
*/
private Map<String, T> cache = new HashMap<>();
private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
public T get(String key) {
// 獲取讀鎖，保證讀期間，數(shù)據(jù)沒有被修改
readWriteLock.readLock().lock();
if(cache.get(key) == null) {
// 從數(shù)據(jù)庫中讀取，并寫入緩存
try {
T value = getDataFromDB(key);
// 先釋放讀鎖
readWriteLock.readLock().unlock();
// 獲取寫鎖
readWriteLock.writeLock().lock();
// 再次判斷是否對(duì)應(yīng)的Key的緩存為空，這是為了防止獲取寫鎖的過程中，已經(jīng)有其它線程寫入了緩存
// 往緩存中寫數(shù)據(jù)
if(cache.get(key) == null) {
cache.put(key, value);
}
// 鎖降級(jí)：持有寫鎖過程中，再獲取讀鎖，再釋放寫鎖：寫鎖->讀鎖
readWriteLock.readLock().lock();
} finally {
// 進(jìn)行后續(xù)操作，可能需要繼續(xù)進(jìn)行讀取數(shù)據(jù)的操作
readWriteLock.writeLock().unlock();
}
}
T value = cache.get(key);
readWriteLock.readLock().unlock();
return value;
}
private T getDataFromDB(String key) {
// 模擬從數(shù)據(jù)庫中讀取數(shù)據(jù)
return (T)new Object();
}
}
2.1 實(shí)現(xiàn)一個(gè)自定義的鎖
2.1.1 從原理開始講解
上一節(jié)講解了synchronized同步關(guān)鍵字，從偏向鎖->輕量級(jí)鎖->重量級(jí)鎖，自己實(shí)現(xiàn)的Lock，先不實(shí)現(xiàn)這么復(fù)雜的東西，從簡單的思路出發(fā)，我們直接來實(shí)現(xiàn)一個(gè)簡單的重量級(jí)鎖，重量級(jí)鎖中有兩個(gè)重要的屬性：鎖池（等待池，即多個(gè)線程爭搶這個(gè)鎖，記錄下這些線程爭搶這個(gè)鎖的Pool）、鎖的擁有者，這里我們先實(shí)現(xiàn)一個(gè)不可重入的鎖，就先不記錄鎖的狀態(tài)了。
基本思路：
package szu.vander.lock;
import szu.vander.log.LogLevel;
import szu.vander.log.Logger;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.LockSupport;
/**
* @author : Vander
* @date : 2019/12/8
* @description : 自定義Lock實(shí)現(xiàn)
*/
public class UserDefinedLock implements Lock {
private final static Logger log = new Logger(false, LogLevel.INFO.getLevel());
/**
* 存放爭搶鎖的線程信息
*/
private volatile LinkedBlockingQueue<Thread> waitLockPool = new LinkedBlockingQueue<>();
/**
* 當(dāng)前鎖的擁有者，存放線程信息
*/
private volatile AtomicReference<Thread> owner = new AtomicReference<>();
@Override
public boolean tryLock() {
if (owner.get() == null) {
return setOwner(Thread.currentThread());
}
return false;
}
@Override
public void lock() {
// 鎖池中的每個(gè)線程都要來嘗試爭搶鎖
while (!tryLock()) {
// 將等待鎖的線程放入等待池中
waitLockPool.add(Thread.currentThread());
// 對(duì)于沒有搶到鎖的線程全都阻塞
log.info("begin to park");
LockSupport.park(Thread.currentThread());
}
waitLockPool.remove(Thread.currentThread());
}
@Override
public void unlock() {
// 當(dāng)前線程執(zhí)行了解鎖
if (owner.compareAndSet(Thread.currentThread(), null)) {
// 通知等待池中的所有線程去爭搶鎖
for (Thread thread: waitLockPool) {
// 此處如果使用waitLockPool.poll去遍歷，速度將會(huì)非常慢
LockSupport.unpark(thread);
}
}
}
/**
* 使用CAS機(jī)制來修改owner的值
*
* @param owner
*/
private boolean setOwner(Thread owner) {
return this.owner.compareAndSet(null, owner);
}
@Override
public void lockInterruptibly() throws InterruptedException {
throw new UnsupportedOperationException();
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
throw new UnsupportedOperationException();
}
@Override
public Condition newCondition() {
throw new UnsupportedOperationException();
}
public static void main(String[] args) {
Lock lock = new UserDefinedLock();
Runnable runnable1 = new Runnable() {
@Override
public void run() {
lock.lock();
log.info("get the this lock, and start sleep");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.info("release the this lock");
lock.unlock();
}
};
for (int i = 0; i < 5; i++) {
new Thread(runnable1).start();
}
}
}
測(cè)試代碼：
package szu.vander.test.lock;
import szu.vander.lock.UserDefinedLock;
import java.util.concurrent.TimeUnit;
/**
* @author : Vander
* @date : 2019/12/8
* @description :
*/
public class UserDefinedLockTest {
private static int sum = 0;
private static UserDefinedLock lock = new UserDefinedLock();
private static int add() {
lock.lock();
sum++;
lock.unlock();
return sum;
}
public static void main(String[] args) throws InterruptedException {
Runnable runnable = new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
add();
}
}
};
for (int i = 0; i < 10; i++) {
new Thread(runnable).start();
}
TimeUnit.SECONDS.sleep(5);
System.out.println("Result : " + sum);
}
}
運(yùn)行結(jié)果：使用10個(gè)線程同時(shí)進(jìn)行累加，不會(huì)出現(xiàn)加不滿10w的情況，說明自定義鎖也不會(huì)存在并發(fā)問題
