本篇文章為大家展示了java中怎么實現(xiàn)一個自旋鎖，內(nèi)容簡明扼要并且容易理解，絕對能使你眼前一亮，通過這篇文章的詳細(xì)介紹希望你能有所收獲。

10年的阜平網(wǎng)站建設(shè)經(jīng)驗，針對設(shè)計、前端、開發(fā)、售后、文案、推廣等六對一服務(wù)，響應(yīng)快，48小時及時工作處理。全網(wǎng)營銷推廣的優(yōu)勢是能夠根據(jù)用戶設(shè)備顯示端的尺寸不同，自動調(diào)整阜平建站的顯示方式，使網(wǎng)站能夠適用不同顯示終端，在瀏覽器中調(diào)整網(wǎng)站的寬度，無論在任何一種瀏覽器上瀏覽網(wǎng)站，都能展現(xiàn)優(yōu)雅布局與設(shè)計，從而大程度地提升瀏覽體驗。創(chuàng)新互聯(lián)建站從事“阜平網(wǎng)站設(shè)計”,“阜平網(wǎng)站推廣”以來，每個客戶項目都認(rèn)真落實執(zhí)行。

什么是自旋鎖？

自旋鎖（spinlock）：是指當(dāng)一個線程在獲取鎖的時候，如果鎖已經(jīng)被其它線程獲取，那么該線程將循環(huán)等待，然后不斷的判斷鎖是否能夠被成功獲取，直到獲取到鎖才會退出循環(huán)。

獲取鎖的線程一直處于活躍狀態(tài)，但是并沒有執(zhí)行任何有效的任務(wù)，使用這種鎖會造成busy-waiting。

它是為實現(xiàn)保護(hù)共享資源而提出一種鎖機(jī)制。其實，自旋鎖與互斥鎖比較類似，它們都是為了解決對某項資源的互斥使用。無論是互斥鎖，還是自旋鎖，在任何時刻，最多只能有一個保持者，也就說，在任何時刻最多只能有一個執(zhí)行單元獲得鎖。但是兩者在調(diào)度機(jī)制上略有不同。對于互斥鎖，如果資源已經(jīng)被占用，資源申請者只能進(jìn)入睡眠狀態(tài)。但是自旋鎖不會引起調(diào)用者睡眠，如果自旋鎖已經(jīng)被別的執(zhí)行單元保持，調(diào)用者就一直循環(huán)在那里看是否該自旋鎖的保持者已經(jīng)釋放了鎖，"自旋"一詞就是因此而得名。

Java如何實現(xiàn)自旋鎖？

下面是個簡單的例子：

public class SpinLock {
private AtomicReference cas = new AtomicReference();
public void lock() {
Thread current = Thread.currentThread();
// 利用CAS
while (!cas.compareAndSet(null, current)) {
// DO nothing
}
}
public void unlock() {
Thread current = Thread.currentThread();
cas.compareAndSet(current, null);
}
}

lock（)方法利用的CAS，當(dāng)?shù)谝粋€線程A獲取鎖的時候，能夠成功獲取到，不會進(jìn)入while循環(huán)，如果此時線程A沒有釋放鎖，另一個線程B又來獲取鎖，此時由于不滿足CAS，所以就會進(jìn)入while循環(huán)，不斷判斷是否滿足CAS，直到A線程調(diào)用unlock方法釋放了該鎖。

自旋鎖存在的問題

1.如果某個線程持有鎖的時間過長，就會導(dǎo)致其它等待獲取鎖的線程進(jìn)入循環(huán)等待，消耗CPU。使用不當(dāng)會造成CPU使用率極高。

2.上面Java實現(xiàn)的自旋鎖不是公平的，即無法滿足等待時間最長的線程優(yōu)先獲取鎖。不公平的鎖就會存在“線程饑餓”問題。

自旋鎖的優(yōu)點

1.自旋鎖不會使線程狀態(tài)發(fā)生切換，一直處于用戶態(tài)，即線程一直都是active的；不會使線程進(jìn)入阻塞狀態(tài)，減少了不必要的上下文切換，執(zhí)行速度快

2.非自旋鎖在獲取不到鎖的時候會進(jìn)入阻塞狀態(tài)，從而進(jìn)入內(nèi)核態(tài)，當(dāng)獲取到鎖的時候需要從內(nèi)核態(tài)恢復(fù)，需要線程上下文切換。 （線程被阻塞后便進(jìn)入內(nèi)核（Linux）調(diào)度狀態(tài)，這個會導(dǎo)致系統(tǒng)在用戶態(tài)與內(nèi)核態(tài)之間來回切換，嚴(yán)重影響鎖的性能）

可重入的自旋鎖和不可重入的自旋鎖

文章開始的時候的那段代碼，仔細(xì)分析一下就可以看出，它是不支持重入的，即當(dāng)一個線程第一次已經(jīng)獲取到了該鎖，在鎖釋放之前又一次重新獲取該鎖，第二次就不能成功獲取到。由于不滿足CAS，所以第二次獲取會進(jìn)入while循環(huán)等待，而如果是可重入鎖，第二次也是應(yīng)該能夠成功獲取到的。

而且，即使第二次能夠成功獲取，那么當(dāng)?shù)谝淮吾尫沛i的時候，第二次獲取到的鎖也會被釋放，而這是不合理的。

為了實現(xiàn)可重入鎖，我們需要引入一個計數(shù)器，用來記錄獲取鎖的線程數(shù)。

public class ReentrantSpinLock {
private AtomicReference cas = new AtomicReference();
private int count;
public void lock() {
Thread current = Thread.currentThread();
if (current == cas.get()) { // 如果當(dāng)前線程已經(jīng)獲取到了鎖，線程數(shù)增加一，然后返回
count++;
return;
}
// 如果沒獲取到鎖，則通過CAS自旋
while (!cas.compareAndSet(null, current)) {
// DO nothing
}
}
public void unlock() {
Thread cur = Thread.currentThread();
if (cur == cas.get()) {
if (count > 0) {// 如果大于0，表示當(dāng)前線程多次獲取了該鎖，釋放鎖通過count減一來模擬
count--;
} else {// 如果count==0，可以將鎖釋放，這樣就能保證獲取鎖的次數(shù)與釋放鎖的次數(shù)是一致的了。
cas.compareAndSet(cur, null);
}
}
}
}

自旋鎖的其他變種

1. TicketLock

TicketLock主要解決的是公平性的問題。

思路：每當(dāng)有線程獲取鎖的時候，就給該線程分配一個遞增的id，我們稱之為排隊號，同時，鎖對應(yīng)一個服務(wù)號，每當(dāng)有線程釋放鎖，服務(wù)號就會遞增，此時如果服務(wù)號與某個線程排隊號一致，那么該線程就獲得鎖，由于排隊號是遞增的，所以就保證了最先請求獲取鎖的線程可以最先獲取到鎖，就實現(xiàn)了公平性。

可以想象成銀行辦理業(yè)務(wù)排隊，排隊的每一個顧客都代表一個需要請求鎖的線程，而銀行服務(wù)窗口表示鎖，每當(dāng)有窗口服務(wù)完成就把自己的服務(wù)號加一，此時在排隊的所有顧客中，只有自己的排隊號與服務(wù)號一致的才可以得到服務(wù)。

實現(xiàn)代碼：

public class TicketLock {
/**
* 服務(wù)號
*/
private AtomicInteger serviceNum = new AtomicInteger();
/**
* 排隊號
*/
private AtomicInteger ticketNum = new AtomicInteger();
/**
* lock:獲取鎖，如果獲取成功，返回當(dāng)前線程的排隊號，獲取排隊號用于釋放鎖. 

*
* @return
*/
public int lock() {
int currentTicketNum = ticketNum.incrementAndGet();
while (currentTicketNum != serviceNum.get()) {
// Do nothing
}
return currentTicketNum;
}
/**
* unlock:釋放鎖，傳入當(dāng)前持有鎖的線程的排隊號 

*
* @param ticketnum
*/
public void unlock(int ticketnum) {
serviceNum.compareAndSet(ticketnum, ticketnum + 1);
}
}

上面的實現(xiàn)方式是，線程獲取鎖之后，將它的排隊號返回，等該線程釋放鎖的時候，需要將該排隊號傳入。但這樣是有風(fēng)險的，因為這個排隊號是可以被修改的，一旦排隊號被不小心修改了，那么鎖將不能被正確釋放。一種更好的實現(xiàn)方式如下：

public class TicketLockV2 {
/**
* 服務(wù)號
*/
private AtomicInteger serviceNum = new AtomicInteger();
/**
* 排隊號
*/
private AtomicInteger ticketNum = new AtomicInteger();
/**
* 新增一個ThreadLocal，用于存儲每個線程的排隊號
*/
private ThreadLocal ticketNumHolder = new ThreadLocal();
public void lock() {
int currentTicketNum = ticketNum.incrementAndGet();
// 獲取鎖的時候，將當(dāng)前線程的排隊號保存起來
ticketNumHolder.set(currentTicketNum);
while (currentTicketNum != serviceNum.get()) {
// Do nothing
}
}
public void unlock() {
// 釋放鎖，從ThreadLocal中獲取當(dāng)前線程的排隊號
Integer currentTickNum = ticketNumHolder.get();
serviceNum.compareAndSet(currentTickNum, currentTickNum + 1);
}
}

上面的實現(xiàn)方式是將每個線程的排隊號放到了ThreadLocal中。

TicketLock存在的問題:

多處理器系統(tǒng)上，每個進(jìn)程/線程占用的處理器都在讀寫同一個變量serviceNum ，每次讀寫操作都必須在多個處理器緩存之間進(jìn)行緩存同步，這會導(dǎo)致繁重的系統(tǒng)總線和內(nèi)存的流量，大大降低系統(tǒng)整體的性能。

下面介紹的MCSLock和CLHLock就是解決這個問題的。

2. CLHLock

CLH鎖是一種基于鏈表的可擴(kuò)展、高性能、公平的自旋鎖，申請線程只在本地變量上自旋，它不斷輪詢前驅(qū)的狀態(tài)，如果發(fā)現(xiàn)前驅(qū)釋放了鎖就結(jié)束自旋，獲得鎖。

實現(xiàn)代碼如下：

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
/**
* CLH的發(fā)明人是：Craig，Landin and Hagersten。
* 代碼來源：http://ifeve.com/java_lock_see2/
*/
public class CLHLock {
/**
* 定義一個節(jié)點，默認(rèn)的lock狀態(tài)為true
*/
public static class CLHNode {
private volatile boolean isLocked = true;
}
/**
* 尾部節(jié)點,只用一個節(jié)點即可
*/
private volatile CLHNode tail;
private static final ThreadLocal LOCAL = new ThreadLocal();
private static final AtomicReferenceFieldUpdater UPDATER = AtomicReferenceFieldUpdater.newUpdater(CLHLock.class, CLHNode.class,
"tail");
public void lock() {
// 新建節(jié)點并將節(jié)點與當(dāng)前線程保存起來
CLHNode node = new CLHNode();
LOCAL.set(node);
// 將新建的節(jié)點設(shè)置為尾部節(jié)點，并返回舊的節(jié)點（原子操作），這里舊的節(jié)點實際上就是當(dāng)前節(jié)點的前驅(qū)節(jié)點
CLHNode preNode = UPDATER.getAndSet(this, node);
if (preNode != null) {
// 前驅(qū)節(jié)點不為null表示當(dāng)鎖被其他線程占用，通過不斷輪詢判斷前驅(qū)節(jié)點的鎖標(biāo)志位等待前驅(qū)節(jié)點釋放鎖
while (preNode.isLocked) {
}
preNode = null;
LOCAL.set(node);
}
// 如果不存在前驅(qū)節(jié)點，表示該鎖沒有被其他線程占用，則當(dāng)前線程獲得鎖
}
public void unlock() {
// 獲取當(dāng)前線程對應(yīng)的節(jié)點
CLHNode node = LOCAL.get();
// 如果tail節(jié)點等于node，則將tail節(jié)點更新為null，同時將node的lock狀態(tài)職位false，表示當(dāng)前線程釋放了鎖
if (!UPDATER.compareAndSet(this, node, null)) {
node.isLocked = false;
}
node = null;
}
}

3. MCSLock

MCSLock則是對本地變量的節(jié)點進(jìn)行循環(huán)。

/**
* MCS:發(fā)明人名字John Mellor-Crummey和Michael Scott
* 代碼來源：http://ifeve.com/java_lock_see2/
*/
public class MCSLock {
/**
* 節(jié)點，記錄當(dāng)前節(jié)點的鎖狀態(tài)以及后驅(qū)節(jié)點
*/
public static class MCSNode {
volatile MCSNode next;
volatile boolean isLocked = true;
}
private static final ThreadLocal NODE = new ThreadLocal();
// 隊列
@SuppressWarnings("unused")
private volatile MCSNode queue;
// queue更新器
private static final AtomicReferenceFieldUpdater UPDATER = AtomicReferenceFieldUpdater.newUpdater(MCSLock.class, MCSNode.class,
"queue");
public void lock() {
// 創(chuàng)建節(jié)點并保存到ThreadLocal中
MCSNode currentNode = new MCSNode();
NODE.set(currentNode);
// 將queue設(shè)置為當(dāng)前節(jié)點，并且返回之前的節(jié)點
MCSNode preNode = UPDATER.getAndSet(this, currentNode);
if (preNode != null) {
// 如果之前節(jié)點不為null，表示鎖已經(jīng)被其他線程持有
preNode.next = currentNode;
// 循環(huán)判斷，直到當(dāng)前節(jié)點的鎖標(biāo)志位為false
while (currentNode.isLocked) {
}
}
}
public void unlock() {
MCSNode currentNode = NODE.get();
// next為null表示沒有正在等待獲取鎖的線程
if (currentNode.next == null) {
// 更新狀態(tài)并設(shè)置queue為null
if (UPDATER.compareAndSet(this, currentNode, null)) {
// 如果成功了，表示queue==currentNode,即當(dāng)前節(jié)點后面沒有節(jié)點了
return;
} else {
// 如果不成功，表示queue!=currentNode,即當(dāng)前節(jié)點后面多了一個節(jié)點，表示有線程在等待
// 如果當(dāng)前節(jié)點的后續(xù)節(jié)點為null，則需要等待其不為null（參考加鎖方法）
while (currentNode.next == null) {
}
}
} else {
// 如果不為null，表示有線程在等待獲取鎖，此時將等待線程對應(yīng)的節(jié)點鎖狀態(tài)更新為false，同時將當(dāng)前線程的后繼節(jié)點設(shè)為null
currentNode.next.isLocked = false;
currentNode.next = null;
}
}
}

4. CLHLock 和 MCSLock

• 都是基于鏈表，不同的是CLHLock是基于隱式鏈表，沒有真正的后續(xù)節(jié)點屬性，MCSLock是顯示鏈表，有一個指向后續(xù)節(jié)點的屬性。

• 將獲取鎖的線程狀態(tài)借助節(jié)點(node)保存,每個線程都有一份獨立的節(jié)點，這樣就解決了TicketLock多處理器緩存同步的問題。

自旋鎖與互斥鎖

• 自旋鎖與互斥鎖都是為了實現(xiàn)保護(hù)資源共享的機(jī)制。

• 無論是自旋鎖還是互斥鎖，在任意時刻，都最多只能有一個保持者。

• 獲取互斥鎖的線程，如果鎖已經(jīng)被占用，則該線程將進(jìn)入睡眠狀態(tài)；獲取自旋鎖的線程則不會睡眠，而是一直循環(huán)等待鎖釋放。

總結(jié)：

• 自旋鎖：線程獲取鎖的時候，如果鎖被其他線程持有，則當(dāng)前線程將循環(huán)等待，直到獲取到鎖。

• 自旋鎖等待期間，線程的狀態(tài)不會改變，線程一直是用戶態(tài)并且是活動的(active)。

• 自旋鎖如果持有鎖的時間太長，則會導(dǎo)致其它等待獲取鎖的線程耗盡CPU。

• 自旋鎖本身無法保證公平性，同時也無法保證可重入性。

• 基于自旋鎖，可以實現(xiàn)具備公平性和可重入性質(zhì)的鎖。

• TicketLock:采用類似銀行排號叫好的方式實現(xiàn)自旋鎖的公平性，但是由于不停的讀取serviceNum，每次讀寫操作都必須在多個處理器緩存之間進(jìn)行緩存同步，這會導(dǎo)致繁重的系統(tǒng)總線和內(nèi)存的流量，大大降低系統(tǒng)整體的性能。

• CLHLock和MCSLock通過鏈表的方式避免了減少了處理器緩存同步，極大的提高了性能，區(qū)別在于CLHLock是通過輪詢其前驅(qū)節(jié)點的狀態(tài)，而MCS則是查看當(dāng)前節(jié)點的鎖狀態(tài)。

• CLHLock在NUMA架構(gòu)下使用會存在問題。在沒有cache的NUMA系統(tǒng)架構(gòu)中，由于CLHLock是在當(dāng)前節(jié)點的前一個節(jié)點上自旋,NUMA架構(gòu)中處理器訪問本地內(nèi)存的速度高于通過網(wǎng)絡(luò)訪問其他節(jié)點的內(nèi)存，所以CLHLock在NUMA架構(gòu)上不是最優(yōu)的自旋鎖。

上述內(nèi)容就是java中怎么實現(xiàn)一個自旋鎖，你們學(xué)到知識或技能了嗎？如果還想學(xué)到更多技能或者豐富自己的知識儲備，歡迎關(guān)注創(chuàng)新互聯(lián)行業(yè)資訊頻道。