public class SpinLock {
private AtomicReference<Thread> cas = new AtomicReference<Thread>();
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);
}
}

public class ReentrantSpinLock {
private AtomicReference<Thread> cas = new AtomicReference<Thread>();
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);
}
}
}
}

public class TicketLock {
/**
* 服務(wù)號
*/
private AtomicInteger serviceNum = new AtomicInteger();
/**
* 排隊號
*/
private AtomicInteger ticketNum = new AtomicInteger();
/**
* lock:獲取鎖，如果獲取成功，返回當(dāng)前線程的排隊號，獲取排隊號用于釋放鎖. <br/>
*
* @return
*/
public int lock() {
int currentTicketNum = ticketNum.incrementAndGet();
while (currentTicketNum != serviceNum.get()) {
// Do nothing
}
return currentTicketNum;
}
/**
* unlock:釋放鎖，傳入當(dāng)前持有鎖的線程的排隊號 <br/>
*
* @param ticketnum
*/
public void unlock(int ticketnum) {
serviceNum.compareAndSet(ticketnum, ticketnum + 1);
}
}

public class TicketLockV2 {
/**
* 服務(wù)號
*/
private AtomicInteger serviceNum = new AtomicInteger();
/**
* 排隊號
*/
private AtomicInteger ticketNum = new AtomicInteger();
/**
* 新增一個ThreadLocal，用于存儲每個線程的排隊號
*/
private ThreadLocal<Integer> ticketNumHolder = new ThreadLocal<Integer>();
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);
}
}

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<CLHNode> LOCAL = new ThreadLocal<CLHNode>();
private static final AtomicReferenceFieldUpdater<CLHLock, CLHNode> 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;
}
}

/**
* 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<MCSNode> NODE = new ThreadLocal<MCSNode>();
// 隊列
@SuppressWarnings("unused")
private volatile MCSNode queue;
// queue更新器
private static final AtomicReferenceFieldUpdater<MCSLock, MCSNode> 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;
}
}
}