Java自旋锁的分类

自旋锁

自旋锁(spin lock)是一个典型的对临界资源的互斥手段，自旋锁是基于CAS原语的，所以它是轻量级的同步操作，它的名称来源于它的特性。自旋锁是指当一个线程尝试获取某个锁时，如果该锁已被其他线程占用，就一直循环检测锁是否被释放，而不是进入线程挂起或睡眠状态。由于自旋锁只不进行线程状态的改变（挂起线程），所以当线程竞争不激烈时，它的响应速度极快（因为避免了线程调度的上下文切换）。自旋锁适用于锁保护的临界区很小的情况，线程竞争不激烈的场景下。如果线程之间竞争激烈或者临界区的操作特别耗时，那么线程的自旋操作就会耗费大量的cpu资源，所以这种情况下性能就会下降明显。

现代计算机CPU的处理结构

由于自旋锁受不同的硬件处理器和架构的影响，我们来简单了解一下相关的知识，重点关注SMP和NUMA。

（1）多线程

（2）多核心

（3）SMP SMP（Symmetric Multi-Processing），对称多处理结构的简称，是指在一个计算机上汇集了一组处理器（多CPU），各CPU之间共享内存子系统以及总线结构。在这种技术的支持下，一个服务器系统可以同时运行多个处理器，并共享内存和其他的主机资源。像双至强，也就是所说的二路，这是在对称处理器系统中最常见的一种（至强MP可以支持到四路，AMD Opteron可以支持1-8路）。也有少数是16路的。但是一般来讲，SMP结构的机器可扩展性较差，很难做到100个以上多处理器，常规的一般是8个到16个，不过这对于多数的用户来说已经够用了。在高性能服务器和工作站级主板架构中最为常见，像UNIX服务器可支持最多256个CPU的系统。

（4）NUMA

NUMA即非一致访问分布共享存储技术，它是由若干通过高速专用网络连接起来的独立节点构成的系统，各个节点可以是单个的CPU或是SMP系统。在NUMA中，Cache 的一致性有多种解决方案，一般采用硬件技术实现对cache的一致性维护，通常需要操作系统针对NUMA访存不一致的特性（本地内存和远端内存访存延迟和带宽的不同）进行特殊优化以提高效率，或采用特殊软件编程方法提高效率。NUMA系统的例子。这里有3个SMP模块用高速专用网络联起来，组成一个节点，每个节点可以有12个CPU。像Sequent的系统最多可以达到64个CPU甚至256个CPU。显然，这是在SMP的基础上，再用NUMA的技术加以扩展，是这两种技术的结合。

（4）乱序执行

（4）分枝技术

（4）控制器

自旋锁的分类及特点

关于自旋锁的种类大体上有四种：

（1）简单自旋锁（非公平）

不能保证公平性

（2）基于票据的自旋锁（公平）

虽然解决了公平性的问题，但是多处理器系统上，每个进程/线程占用的处理器都在读写同一个变量serviceNum ，每次读写操作都必须在多个处理器缓存之间进行缓存同步，这会导致繁重的系统总线和内存的流量，大大降低系统整体的性能

（3）CLH自旋锁（公平）

作者：CLH：Craig，Landin and Hagersten。锁的名称都来源于发明人的名字首字母

CLH自旋锁是一种基于隐式链表（节点里面没有next指针）的可扩展、高性能、公平的自旋锁，申请线程只在本地变量上自旋，它不断轮询前驱的状态，如果发现前驱释放了锁就结束自旋。CLH队列锁的优点是空间复杂度低（如果有n个线程，L个锁，每个线程每次只获取一个锁，那么需要的存储空间是O（L+n），n个线程有n个。myNode，L个锁有L个tail），CLH的一种变体被应用在了JAVA并发框架中。 CLH在SMP系统结构下该法是非常有效的。但在NUMA系统结构下，每个线程有自己的内存，如果前趋结点的内存位置比较远，自旋判断前趋结点的locked域，性能将大打折扣

（4）MCS自旋锁（公平）

作者：MCS：John Mellor-Crummey and Michael Scott。锁的名称都来源于发明人的名字首字母

MCS Spinlock是一种基于显式链表（节点里面拥有next指针）的可扩展、高性能、公平的自旋锁，申请线程只在本地变量上自旋，由直接前驱负责通知其结束自旋（与CLH自旋锁不同的地方，不在轮询前驱的状态，而是由前驱主动通知），从而极大地减少了不必要的处理器缓存同步的次数，降低了总线和内存的开销。而MCS是在自己的结点的locked域上自旋等待。正因为如此，它解决了CLH在NUMA系统架构中获取locked域状态内存过远的问题。

实现CLH和MCS自旋锁

关于简单的自旋锁和基于票号的自旋锁前面的文章已经介绍过，这里不再重复介绍。

首先看CLH自旋锁的实现方式：

import java.util.concurrent.atomic.AtomicReference;

/**

Created by qindongliang on 2018/8/5.
*/
public class CLHLock {

class Node{
//false代表没人占用锁
volatile boolean locked=false;
}

//指向最后加入的线程
final AtomicReference<Node> tail=new AtomicReference<>(new Node());

//使用ThreadLocal保证每个线程副本内都有一个Node对象
final ThreadLocal<Node> current;

public CLHLock(){
//初始化当前节点的node
current=new ThreadLocal<Node>(){
@Override
protected Node initialValue() {
return new Node();
}
};

}

public void lock() throws InterruptedException {

//得到当前线程的Node节点
Node own=current.get();
 //修改为true，代表当前线程需要获取锁
 own.locked=true;

 //设置当前线程去注册锁，注意在多线程下环境下，这个
 //方法仍然能保持原子性，，并返回上一次的加锁节点（前驱节点）
 Node preNode=tail.getAndSet(own);

 //在前驱节点上自旋
 while(preNode.locked){
     System.out.println(Thread.currentThread().getName()+" 开始自旋....  ");
     Thread.sleep(2000);
 }

}

public void unlock(){

 //当前线程如果释放锁，只要将占用状态改为false即可
 //因为其他的线程会轮询自己，所以volatile布尔变量改变之后
 //会保证下一个线程能立即看到变化，从而得到锁
 current.get().locked=false;

}

public static void main(String[] args) throws InterruptedException {

 CLHLock lock=new CLHLock();

 Runnable runnable=new Runnable() {
     @Override
     public void run() {
         try {
             lock.lock();
             System.out.println(Thread.currentThread().getName()+"  获得锁 ");
             //前驱释放，do own work
             Thread.sleep(5000);
             System.out.println(Thread.currentThread().getName()+"  释放锁 ");
             lock.unlock();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
 };

 Thread t1=new Thread(runnable,"线程1");
 Thread t2=new Thread(runnable,"线程2");
 Thread t3=new Thread(runnable,"线程3");

 t1.start();
 t2.start();
 t3.start();

}

}</pre>

在三个线程下面的输出结果：

MCS锁的实现方式：

import java.util.concurrent.atomic.AtomicReference;

/**

Created by qindongliang on 2018/8/5.
*/
public class MCSLock {

class Node{
volatile Node next;//后继节点
//默认false
volatile boolean locked;
}

//指向最后加入的线程
final AtomicReference<MCSLock.Node> tail=new AtomicReference<>(null);

ThreadLocal<Node> current;

public MCSLock(){
//初始化当前节点的node
current=new ThreadLocal<MCSLock.Node>(){
@Override
protected MCSLock.Node initialValue() {
return new MCSLock.Node();
}
};
}

public void lock() throws InterruptedException {

 //获取当前线程的Node
 Node own=current.get();

 //获取前驱节点
 Node preNode=tail.getAndSet(own);

 //如果前驱节点不为null，说明有线程已经占用
 if(preNode!=null){
     //设置当前节点为需要占用状态；
     own.locked=true;
     //把前面节点的next指向自己
     preNode.next=own;

     //在自己的节点上自旋等待前驱通知
     while(own.locked){

         System.out.println(Thread.currentThread().getName()+" 开始自旋....  ");
         Thread.sleep(2000);

     }

 }

 System.out.println(Thread.currentThread().getName()+" 获得了锁....  ");

}

public void unlock(){
//获取自己的节点
Node own=current.get();
//
if(own.next==null){
//判断是不是自身是不是最后一个线程
if(tail.compareAndSet(own,null)){
//是的话就结束
return;
}

     //在判断过程中，又有线程进来
     while (own.next==null){

     }

 }
 //本身解锁，通知它的后继节点可以工作了，不用再自旋了
 own.next.locked=false;
 own.next=null;// for gc

}

public static void main(String[] args) {

 MCSLock lock=new MCSLock();

 Runnable runnable=new Runnable() {
     @Override
     public void run() {
         try {
             lock.lock();
             System.out.println(Thread.currentThread().getName()+"  获得锁 ");
             //前驱释放，do own work
             Thread.sleep(4000);
             System.out.println(Thread.currentThread().getName()+"  释放锁 ");
             lock.unlock();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }

     }
 };

 Thread t1=new Thread(runnable,"线程1");
 Thread t2=new Thread(runnable,"线程2");
 Thread t3=new Thread(runnable,"线程3");

 t1.start();
 t2.start();
 t3.start();

}

}</pre>

输出结果：

详细介绍，在代码的注释里面写的很清楚了，这里再给一张图来帮助我们我们理解基于链表实现公平方式的过程：

image

CLH 对比 MCS

（1）从代码实现来看，CLH比MCS要简单得多。

（2）从自旋的条件来看，CLH是在前驱节点的属性上自旋，而MCS是在本地属性变量上自旋。

（3）从链表队列来看，CLH的队列是隐式的，CLHNode并不实际持有下一个节点；MCS的队列是物理存在的。

（4）CLH锁释放时只需要改变自己的属性，MCS锁释放则需要改变后继节点的属性。

（5）CLH适合CPU个数不多的计算机硬件架构上，MCS则适合拥有很多CPU的硬件架构上

（6）CLH和MCS实现的自旋锁都是不可重入的

总结

本文主要介绍了目前主流的4种自旋锁的特点和实现，此外众所周知，AbstractQueuedSynchronizer是Java并发包的基石之一，而CLH锁的原理和思想则是AbstractQueuedSynchronizer的基石之一，JDK里面的CLH锁的是增强改进后的CLH锁。理解清楚CLH锁的原理和实现对后面学习和理解AbstractQueuedSynchronizer是非常重要的。最后文中所有的代码已经上传我的github上，感兴趣的朋友可以研究学习。

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 214,837评论 6赞 496
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 91,551评论 3赞 389
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 160,417评论 0赞 350
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 57,448评论 1赞 288
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 66,524评论 6赞 386
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 50,554评论 1赞 293
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 39,569评论 3赞 414
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 38,316评论 0赞 270
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,766评论 1赞 307
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 37,077评论 2赞 330
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 39,240评论 1赞 343
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 34,912评论 5赞 338
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 40,560评论 3赞 322
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 31,176评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,425评论 1赞 268
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 47,114评论 2赞 366
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 44,114评论 2赞 352

Java自旋锁的分类

自旋锁

现代计算机CPU的处理结构

自旋锁的分类及特点

实现CLH和MCS自旋锁

总结

推荐阅读更多精彩内容