Java锁之自旋锁详解
锁作为并发共享数据，保证一致性的工具，在java平台有多种实现(如 synchronized 和 reentrantlock等等 ) 。这些已经写好提供的锁为我们开发提供了便利，但是锁的具体性质以及类型却很少被提及。本系列文章将分析java下常见的锁名称以及特性，为大家答疑解惑。
1、自旋锁
自旋锁是采用让当前线程不停地的在循环体内执行实现的，当循环的条件被其他线程改变时 才能进入临界区。如下
public class spinlock {
private atomicreference<thread> sign =new atomicreference<>();
public void lock(){
thread current = thread.currentthread();
while(!sign .compareandset(null, current)){
}
}
public void unlock (){
thread current = thread.currentthread();
sign .compareandset(current, null);
}
}
使用了cas原子操作，lock函数将owner设置为当前线程，并且预测原来的值为空。unlock函数将owner设置为null，并且预测值为当前线程。
当有第二个线程调用lock操作时由于owner值不为空，导致循环一直被执行，直至第一个线程调用unlock函数将owner设置为null，第二个线程才能进入临界区。
由于自旋锁只是将当前线程不停地执行循环体，不进行线程状态的改变，所以响应速度更快。但当线程数不停增加时，性能下降明显，因为每个线程都需要执行，占用cpu时间。如果线程竞争不激烈，并且保持锁的时间段。适合使用自旋锁。
注：该例子为非公平锁，获得锁的先后顺序，不会按照进入lock的先后顺序进行。
2.自旋锁的其他种类
上文我们讲到了自旋锁，在自旋锁中 另有三种常见的锁形式:ticketlock ，clhlock 和mcslock
ticket锁主要解决的是访问顺序的问题，主要的问题是在多核cpu上:
package com.alipay.titan.dcc.dal.entity;
import java.util.concurrent.atomic.atomicinteger;
public class ticketlock {
private atomicinteger servicenum = new atomicinteger();
private atomicinteger ticketnum = new atomicinteger();
private static final threadlocal<integer> local = new threadlocal<integer>();
public void lock() {
int myticket = ticketnum.getandincrement();
local.set(myticket);
while (myticket != servicenum.get()) {
}
}
public void unlock() {
int myticket = local.get();
servicenum.compareandset(myticket, myticket + 1);
}
}
每次都要查询一个servicenum 服务号，影响性能（必须要到主内存读取，并阻止其他cpu修改）。
clhlock 和mcslock 则是两种类型相似的公平锁，采用链表的形式进行排序。
import java.util.concurrent.atomic.atomicreferencefieldupdater;
public class clhlock {
public static class clhnode {
private volatile boolean islocked = true;
}
@suppresswarnings("unused")
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() {
clhnode node = new clhnode();
local.set(node);
clhnode prenode = updater.getandset(this, node);
if (prenode != null) {
while (prenode.islocked) {
}
prenode = null;
local.set(node);
}
}
public void unlock() {
clhnode node = local.get();
if (!updater.compareandset(this, node, null)) {
node.islocked = false;
}
node = null;
}
}
clhlock是不停的查询前驱变量， 导致不适合在numa 架构下使用（在这种结构下，每个线程分布在不同的物理内存区域）
mcslock则是对本地变量的节点进行循环。不存在clhlock 的问题。
import java.util.concurrent.atomic.atomicreferencefieldupdater;
public class mcslock {
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;
private static final atomicreferencefieldupdater<mcslock, mcsnode> updater = atomicreferencefieldupdater.newupdater(mcslock.class,
mcsnode.class, "queue");
public void lock() {
mcsnode currentnode = new mcsnode();
node.set(currentnode);
mcsnode prenode = updater.getandset(this, currentnode);
if (prenode != null) {
prenode.next = currentnode;
while (currentnode.islocked) {
}
}
}
public void unlock() {
mcsnode currentnode = node.get();
if (currentnode.next == null) {
if (updater.compareandset(this, currentnode, null)) {
} else {
while (currentnode.next == null) {
}
}
} else {
currentnode.next.islocked = false;
currentnode.next = null;
}
}
}
从代码上 看，clh 要比 mcs 更简单，
clh 的队列是隐式的队列，没有真实的后继结点属性。
mcs 的队列是显式的队列，有真实的后继结点属性。
juc reentrantlock 默认内部使用的锁 即是 clh锁（有很多改进的地方，将自旋锁换成了阻塞锁等等）。
（全文完）