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;
}
// 如果沒(méi)獲取到鎖，則通過(guò)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)前線程多次獲取了該鎖，釋放鎖通過(guò)count減一來(lái)模擬
count--;
} else {// 如果count==0，可以將鎖釋放，這樣就能保證獲取鎖的次數(shù)與釋放鎖的次數(shù)是一致的了。
cas.compareAndSet(cur, null);
}
}
}
}

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

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

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
/**
* CLH的發(fā)明人是：Craig，Landin and Hagersten。
* 代碼來(lái)源：http://ifeve.com/java_lock_see2/
*/
public class CLHLock {
/**
* 定義一個(gè)節(jié)點(diǎn)，默認(rèn)的lock狀態(tài)為true
*/
public static class CLHNode {
private volatile boolean isLocked = true;
}
/**
* 尾部節(jié)點(diǎn),只用一個(gè)節(jié)點(diǎn)即可
*/
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é)點(diǎn)并將節(jié)點(diǎn)與當(dāng)前線程保存起來(lái)
CLHNode node = new CLHNode();
LOCAL.set(node);
// 將新建的節(jié)點(diǎn)設(shè)置為尾部節(jié)點(diǎn)，并返回舊的節(jié)點(diǎn)（原子操作），這里舊的節(jié)點(diǎn)實(shí)際上就是當(dāng)前節(jié)點(diǎn)的前驅(qū)節(jié)點(diǎn)
CLHNode preNode = UPDATER.getAndSet(this, node);
if (preNode != null) {
// 前驅(qū)節(jié)點(diǎn)不為null表示當(dāng)鎖被其他線程占用，通過(guò)不斷輪詢判斷前驅(qū)節(jié)點(diǎn)的鎖標(biāo)志位等待前驅(qū)節(jié)點(diǎn)釋放鎖
while (preNode.isLocked) {
}
preNode = null;
LOCAL.set(node);
}
// 如果不存在前驅(qū)節(jié)點(diǎn)，表示該鎖沒(méi)有被其他線程占用，則當(dāng)前線程獲得鎖
}
public void unlock() {
// 獲取當(dāng)前線程對(duì)應(yīng)的節(jié)點(diǎn)
CLHNode node = LOCAL.get();
// 如果tail節(jié)點(diǎn)等于node，則將tail節(jié)點(diǎn)更新為null，同時(shí)將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
* 代碼來(lái)源：http://ifeve.com/java_lock_see2/
*/
public class MCSLock {
/**
* 節(jié)點(diǎn)，記錄當(dāng)前節(jié)點(diǎn)的鎖狀態(tài)以及后驅(qū)節(jié)點(diǎn)
*/
public static class MCSNode {
volatile MCSNode next;
volatile boolean isLocked = true;
}
private static final ThreadLocal<MCSNode> NODE = new ThreadLocal<MCSNode>();
// 隊(duì)列
@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é)點(diǎn)并保存到ThreadLocal中
MCSNode currentNode = new MCSNode();
NODE.set(currentNode);
// 將queue設(shè)置為當(dāng)前節(jié)點(diǎn)，并且返回之前的節(jié)點(diǎn)
MCSNode preNode = UPDATER.getAndSet(this, currentNode);
if (preNode != null) {
// 如果之前節(jié)點(diǎn)不為null，表示鎖已經(jīng)被其他線程持有
preNode.next = currentNode;
// 循環(huán)判斷，直到當(dāng)前節(jié)點(diǎn)的鎖標(biāo)志位為false
while (currentNode.isLocked) {
}
}
}
public void unlock() {
MCSNode currentNode = NODE.get();
// next為null表示沒(méi)有正在等待獲取鎖的線程
if (currentNode.next == null) {
// 更新?tīng)顟B(tài)并設(shè)置queue為null
if (UPDATER.compareAndSet(this, currentNode, null)) {
// 如果成功了，表示queue==currentNode,即當(dāng)前節(jié)點(diǎn)后面沒(méi)有節(jié)點(diǎn)了
return;
} else {
// 如果不成功，表示queue!=currentNode,即當(dāng)前節(jié)點(diǎn)后面多了一個(gè)節(jié)點(diǎn)，表示有線程在等待
// 如果當(dāng)前節(jié)點(diǎn)的后續(xù)節(jié)點(diǎn)為null，則需要等待其不為null（參考加鎖方法）
while (currentNode.next == null) {
}
}
} else {
// 如果不為null，表示有線程在等待獲取鎖，此時(shí)將等待線程對(duì)應(yīng)的節(jié)點(diǎn)鎖狀態(tài)更新為false，同時(shí)將當(dāng)前線程的后繼節(jié)點(diǎn)設(shè)為null
currentNode.next.isLocked = false;
currentNode.next = null;
}
}
}