【锁】自旋锁-MCS/CLH队列

最新推荐文章于 2023-07-21 20:06:53 发布
最新推荐文章于 2023-07-21 20:06:53 发布
阅读量2.4k 收藏 1
点赞数 2
分类专栏： 并发 java 锁 文章标签： 链表 队列 多线程 并发编程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aaa_bbb_ccc_123_456/article/details/103627310
版权
java 同时被 3 个专栏收录
38 篇文章 4 订阅
订阅专栏
并发
8 篇文章 0 订阅
订阅专栏
锁
7 篇文章 0 订阅
订阅专栏
1.自旋锁-MCS/CLH队列
2.自旋锁
  • 指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上线文切换的消耗，缺点是循环会消耗CPU

2.1 CAS

JUC包里的AtomicInteger类底层用CAS机制的实现就是一种自旋锁，以下是其底层核心类UnSafe的一段源码：
在这里插入图片描述
具体可查看:【JUC】 Java中的CAS

2.2 我们来自己实现一个简单的自旋锁，Demo:

/**
 * 手写一个自旋锁：循环比较知道成功为止
 *
 * @author wangjie
 * @version V1.0
 * @date 2019/12/18
 */
public class SpinLockDemo {

    /**
     *  原子引用线程
     */
    AtomicReference<Thread> atomicReference = new AtomicReference();

    public void myLock(){

        Thread thread = Thread.currentThread();

        System.out.println(Thread.currentThread().getName()+"\t come in");

        while (!atomicReference.compareAndSet(null,thread)){

        }
    }

    public void myUnLock(){

        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread,null);
        System.out.println(Thread.currentThread().getName()+"\t in myUnLock()");
    }

    public static void main(String[] args) {

        SpinLockDemo spinLockDemo = new SpinLockDemo();

        new Thread(()->{
            spinLockDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.myUnLock();
        },"AA").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            spinLockDemo.myLock();

            spinLockDemo.myUnLock();
        },"BB").start();

    }
}
  • 运行结果：
    在这里插入图片描述
3.MCS 自旋锁
  • MCS含义：

发明人的名字：John Mellor-Crummey和Michael Scot

  • 介绍：

MCS 队列基于链表实现，每个申请锁的线程都是链表上的一个节点，这些线程会一直轮询自己的本地变量，来知道它自己是否获得了锁。已经获得了锁的线程在释放锁的时候，负责通知其它线程，这样 CPU 之间缓存的同步操作就减少了很多，仅在线程通知另外一个线程的时候发生，降低了系统总线和内存的开销。

  • Demo：
/**
 * MCS自旋锁
 *
 * @author wangjie
 * @version V1.0
 * @date 2019/12/20
 */
public class MCSLock {

    /**
     * 链表节点
     */
    public static class MCSNode {
        volatile MCSNode next;
        volatile boolean isWaiting = true; // 默认是在等待锁
        MCSNode(){

        }
    }

    /**
     * 指向最后一个申请锁的MCSNode
     */
    volatile MCSNode queue;


    /**
     * 一个基于反射的工具类，它能对指定类的指定的volatile引用字段进行原子更新。(注意这个字段不能是private的)
     *
     * 通过调用AtomicReferenceFieldUpdater的静态方法newUpdater就能创建它的实例，该方法要接收三个参数：
     *     包含该字段的对象的类
     *     将被更新的对象的类
     *     将被更新的字段的名称
     */
    private static final AtomicReferenceFieldUpdater<MCSLock, MCSNode> UPDATER = AtomicReferenceFieldUpdater
            .newUpdater(MCSLock.class, MCSNode.class, "queue");


    public void lock(MCSNode currentThread) {

        System.out.println(Thread.currentThread().getName()+"\t come in");

        /**
         * 原子更新该更新器管理的指定对象的字段的值为newValue，返回旧值
         */
        MCSNode predecessor = UPDATER.getAndSet(this, currentThread);
        //前个节点不为null
        if (predecessor != null) {
            //设置前一个节点指向当前节点
            predecessor.next = currentThread;
            while (currentThread.isWaiting) {
                //自旋自己的isWaiting
                System.out.println(Thread.currentThread().getName()+"\t Waiting");
            }
        } else { // 只有一个线程在使用锁，没有前驱来通知它，所以得自己标记自己已获得锁
            currentThread.isWaiting = false;
            System.out.println(Thread.currentThread().getName()+"\t get lock");
        }
    }

    public void unlock(MCSNode currentThread) {

        System.out.println(Thread.currentThread().getName()+"\t in UnLock()");

        if (currentThread.isWaiting) {
            return;
        }
         // 检查是否有人排在自己后面
        if (currentThread.next == null) {
            if (UPDATER.compareAndSet(this, currentThread, null)) {
                // compareAndSet返回true表示确实没有人排在自己后面
                return;
            } else {
                // 突然有人排在自己后面了，可能还不知道是谁，下面是等待后续者
                while (currentThread.next == null) {
                }
            }
        }
        currentThread.next.isWaiting = false;
        // 辅助GC
        currentThread.next = null;
    }

    public static void main(String[] args) {

        MCSLock mCSLock = new MCSLock();

        new Thread(()->{
            MCSNode node = new MCSNode();
            mCSLock.lock(node);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            mCSLock.unlock(node);
        },"AA").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            MCSNode node = new MCSNode();
            mCSLock.lock(node);
            mCSLock.unlock(node);
        },"BB").start();

    }
}
  • 运行结果：
    在这里插入图片描述
    在这里插入图片描述
4.CLH 自旋锁
  • CLH含义：

与他们的发明人的名字相关：Craig，Landin and Hagersten

  • 介绍：

CLH 锁与 MCS 锁的原理大致相同，都是各个线程轮询各自关注的变量，来避免多个线程对同一个变量的轮询，从而从 CPU 缓存一致性的角度上减少了系统的消耗。不同的是，MCS 轮询的是当前队列节点的变量，而 CLH 轮询的是当前节点的前驱节点的变量，来判断前一个线程是否释放了锁。

  • Demo:
/**
 * CLH队列自旋锁
 *
 * @author wangjie
 * @version V1.0
 * @date 2019/12/20
 */
public class CLHLock {

    public static class CLHNode {
        private volatile boolean isWaiting = true; // 默认是在等待锁
    }

    /**
     * 尾节点
     */
    private volatile CLHNode tail ;

    /**
     * 一个基于反射的工具类，它能对指定类的指定的volatile引用字段进行原子更新。(注意这个字段不能是private的)
     *
     * 通过调用AtomicReferenceFieldUpdater的静态方法newUpdater就能创建它的实例，该方法要接收三个参数：
     *     包含该字段的对象的类
     *     将被更新的对象的类
     *     将被更新的字段的名称
     */
    private static final AtomicReferenceFieldUpdater<CLHLock, CLHNode> UPDATER = AtomicReferenceFieldUpdater
            . newUpdater(CLHLock.class, CLHNode .class , "tail" );


    public void lock(CLHNode currentThread) {
        CLHNode preNode = UPDATER.getAndSet( this, currentThread);

        //已有线程占用了锁，进入自旋
        if(preNode != null) {
            while(preNode.isWaiting ) {
                System.out.println(Thread.currentThread().getName()+"\t Waiting");
            }
        }
    }

    public void unlock(CLHNode currentThread) {
        // 如果队列里只有当前线程，则释放对当前线程的引用（for GC）。
        if (!UPDATER .compareAndSet(this, currentThread, null)) {
            // 还有后续线程
            // 改变状态，让后续线程结束自旋
            System.out.println(Thread.currentThread().getName()+"\t unlock");
            currentThread.isWaiting = false ;
        }
    }
    public static void main(String[] args) {

        CLHLock cLHLock = new CLHLock();

        new Thread(()->{
            CLHNode node = new CLHNode();
            cLHLock.lock(node);
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            cLHLock.unlock(node);
        },"AA").start();

        try {
            TimeUnit.MILLISECONDS.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            CLHNode node = new CLHNode();
            cLHLock.lock(node);
            cLHLock.unlock(node);
        },"BB").start();

    }
}
  • 运行结果：
    在这里插入图片描述
    总结

1,CLH是在前驱节点的属性上自旋，而MCS是在本地属性变量上自旋。

2，CLH的队列是隐式的，通过轮询关注上一个节点的某个变量，隐式地形成了链式的关系，但CLHNode并不实际持有下一个节点，MCS的队列是物理存在的，而 CLH 的队列是逻辑上存在的

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

【完】
注：文章内所有测试用例源码：https://gitee.com/wjie2018/test-case.git

wj-1024
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
自旋－1/2近似下双势阱中纠缠制备和特性研究
02-13
作为量子理论的基础研究，在巨观系统中制备多粒子纠缠态一直是重要的课题，运用自旋－1/2近似的方法，研究束缚在双势阱中的两成份玻色爱因斯坦(Bose-Einstein)凝聚体系的纠缠态生成问题。这种近似在稳定隧穿条件和...
Java锁之自旋锁详解
09-04
3. CLHLock（Craig, Landin, and Hagersten Lock）和MCSLock（Mellor-Crummey and Scott Lock）：这两种自旋锁是基于链表结构的公平锁，它们将等待线程组织成一个队列，并使用`AtomicReferenceFieldUpdater`等原子...
【转】自旋锁、排队自旋锁、MCS锁、CLH锁
三思而后行
11-30 684
原文： http://coderbee.net/index.php/java/20131115/577 好文，万一哪天原文的博客关闭链接失效了，转来留底。 自旋锁（Spin lock） 自旋锁是指当一个线程尝试获取某个锁时，如果该锁已被其他线程占用，就一直循环检测锁是否被释放，而不是进入线程挂起或睡眠状态。 自旋锁适用于锁保护的临界区很小的情况，临界区很小的话，锁占用的时间就很短。 简...
「并发原理专题」AQS的技术体系之CLH、MCS锁的原理及实现，java架构和java开发
m0_64205605的博客
11-18 256
在SMP架构下，CLH更具有优势。 在NUMA架构下，如果当前节点与前驱节点不在同一CPU模块下，跨CPU模块会带来额外的系统开销，而MCS锁更适用于NUMA架构。 加锁逻辑 1.获取当前线程的锁节点，如果为空，则进行初始化； 2.同步方法获取链表的尾节点，并将当前节点置为尾节点，此时原来的尾节点为当前节点的前置节点。 3.如果尾节点为空，表示当前节点是第一个节点，直接加锁成功。 如果尾节点不为空，则基于前置节点的锁值（locked==true）进行自旋，直到前置节点的锁值变为false。 ...
【Java】CLH 自旋锁
u010900754的专栏
08-22 517
看java重入锁的代码，遇到了CLH队列锁，发现实现很巧妙，学习一下。 什么是自旋锁？说的是锁等待的实现方式，可以改变线程的状态，让其进入等待或者睡眠（具体状态还没研究），这就是使用线程最原生的方式实现。也可以让线程进入一个while循环，这是一种轻量级实现，没有设计线程状态的转换，节省了转换的开销，但是cpu开销可能很大，进入循环的方式就是自旋锁。 下面是一段很常见的理解CLH的代码： c
clh自旋锁
远方的少年
04-29 137
aqs中使用的FIFO队列是clh自旋锁的一个变种，所以理解clh对理解aqs很有帮助。 自旋锁适合于加锁时间短的任务，一直忙等。互斥锁适合加锁时间长的任务，需要wait,notify。 附上clh自旋锁java实现。 public class CLHLock { private class Node { private volatile boolean locked; public boolean is...
CLH自旋锁
important0534的专栏
02-21 700
CLH锁即Craig, Landin, and Hagersten (CLH) locks，CLH锁是一个自旋锁，能确保无饥饿性，提供先来先服务的公平性。 CLHLock的java实现逻辑: public class CLHLock implements Lock { private final AtomicReference tail; pri
golang实现Redis分布式自旋锁+本地自旋锁
01-20
在Golang中，实现分布式自旋锁和本地自旋锁是一种常见的并发控制策略，用于解决多线程或分布式系统中的资源竞争问题。自旋锁的基本思想是，当一个线程试图获取锁时，如果锁已被其他线程持有，它会不断地检查锁的状态...
自旋和角动量-Oriyao.pdf
最新发布
09-01
塞曼效应是解释这种现象的经典实验，它表明在磁场中，由于自旋-轨道耦合，光谱线会分裂成多条。 **自旋的单态和三重态** 自旋单态意味着所有电子的自旋态是反对称的，即自旋总和为零，而自旋三重态则意味着存在三个...
Linux内核同步机制-自旋锁
08-08
自旋锁的基本思想是当一个线程试图获取已被其他线程持有的锁时，它会不断地检查锁的状态，即“自旋”等待，直到锁被释放为止。由于自旋锁不会导致调用者进入睡眠状态，因此它主要适用于那些持有锁的时间非常短的操作...
CLH队列cas自旋锁实现
GAVIN12365的博客
10-09 173
CLH队列 CLH队列中的结点QNode中含有一个locked字段，该字段若为true表示该线程需要获取锁，且不释放锁，为false表示线程释放了锁。结点之间是通过隐形的链表相连，之所以叫隐形的链表是因为这些结点之间没有明显的next指针，而是通过myPred所指向的结点的变化情况来影响myNode的行为。CLHLock上还有一个尾指针，始终指向队列的最后一个结点 当一个线程需要获取锁时，会创建一个新的QNode，将其中的locked设置为true表示需要获取锁，然后线程对tail域调用getAndSet方
并发编程(5)-CLH与MCS队列锁
u010636239的博客
04-07 230
自旋锁 一般解决多线程共享资源逻辑一致性问题有两种方式： 互斥锁：发现资源被占用时，阻塞自己直到资源解除占用，然后再次尝试获取锁； 自旋锁：发现资源占用时，一直尝试获取锁，线程不会被挂起，即没有线程调度切换的消耗； SMP 对称多处理（Symmetrical Multi-Processing），是指在一个计算机上汇集了一组处理器(多CPU),各CPU之间共...
并发系列（3）之 CLH、MCS 队列锁简介
weixin_30659829的博客
03-20 111
这篇博客主要是作为 AbstractQueuedSynchronizer 的背景知识介绍；平时接触也非常的少，如果你不感兴趣可以跳过；但是了解一下能更加的清楚 AQS 的设计思路； 一、自旋锁简介 通常情况下解决多线程共享资源逻辑一致性问题有两种方式： 互斥锁：当发现资源被占用的时候，会阻塞自己直到资源解除占用，然后再次尝试获取； 自旋锁：当发现占用时，一直尝试获取锁（线程没有被挂起的过程，也就...
线程安全自旋锁的实现与 CLH 队列解析
yygr的博客
02-13 212
https://segmentfault.com/a/1190000016416947 阻塞同步 在 Java 中，我们经常使用 synchronized 关键字来做到互斥同步以解决多线程并发访问共享数据的问题。synchronzied 关键字在编译后，会在 synchronized 所包含的同步代码块前后分别加入 monitorenter 和 monitorexit 这两个字节码指令。synchronized 关键字需要指定一个对象来进行加锁和解锁。例如： public class Main { priv
CLH自旋锁的简易实现
More than coding
02-18 239
前言 我们知道，当一个线程想要申请的锁已经被其他线程持有时，那么该线程需要等待其释放锁。等待的方式有两种：一种是将线程状态置为等待状态（非RUNNABLE），另一种就是自旋了。自旋就是不断检测该锁是否被释放，而不是将线程挂起或休眠。这两种方式适用于不同的场景。 当线程持有锁的时间较长时（一般情况下，也可以理解为，临界区代码较长），适合使用将线程挂起或休眠的方式，因为自旋太久会消耗大量CPU计算资源；当线程持有锁的时间较短时，适合自旋等待的方式，因为线程被挂起或休眠后需要被唤醒，而频繁的唤醒与挂起线程会导致大
CLH自旋锁原理
Cheney的博客
07-21 229
在争夺锁激烈的情况下，为了减少CAS空自旋（CAS需要CPU进行内部通信保证缓存一致性造成流量过大引起总线风暴），Java轻量级锁会升级为重量级锁，那么JUC基于CAS实现的轻量级锁如何避免总线风暴呢？CLH锁其实就是一种是基于队列（具体为单向链表）排队的自旋锁，申请加锁的线程首先会通过CAS操作在单向链表的尾部增加一个节点，之后该线程只需要在其前驱节点上进行。抢锁线程在队列尾部加入一个节点，然后仅在前驱节点上做普通自旋，它不断轮询前一个节点状态，如果发现前一个节点释放锁，当前节点抢锁成功。
自旋锁，排队自旋锁，clh 锁，mcs 锁
u011779268的博客
08-04 391
http://blog.csdn.net/fei33423/article/details/30316377
java juc 自旋锁_玩转Java并发工具，精通JUC，成为并发多面手
weixin_36263314的博客
02-26 676
课程介绍:在处理Java并发问题时，需要使用各种工具。但市面上缺少对并发工具成体系的讲解。本课程深度解密JUC库，对Java并发常见的工具类进行从使用到原理的详解，包括CAS+AQS+ThreadLocal+ConcurrentHashMap+线程池+各种锁+并发综合实战项目等。在掌握工具的同时，建立起整个并发工具类的知识体系，并上手一个高性能缓存的实战项目。课程对于面试和实际工作都非常有帮助，还...
CLH锁 、MCS锁
huapro.vip的程序人生
02-15 465
一。引文 1.1 SMP(Symmetric Multi-Processor) 对称多处理器结构，指服务器中多个CPU对称工作，每个CPU访问内存地址所需时间相同。其主要特征是共享，包含对CPU，内存，I/O等进行共享。 SMP能够保证内存一致性，但这些共享的资源很可能成为性能瓶颈，随着CPU数量的增加，每个CPU都要访问相同的内存资源，可能导致内存访问冲突， 可能会导致CPU资源的浪费。常用的PC机就属于这种。 1.2 NUMA(Non-Uniform Memory Access) 非一致存储访问，将CP
自旋量子数为3/2的元素
06-13
自旋量子数为3/2的元素是指具有3/2整数自旋量子数的元素。在化学中，最常见的自旋量子数为3/2的元素是钴（Co）和铁（Fe）等过渡金属元素的同位素，如铁的同位素^57Fe和钴的同位素^59Co。这些元素的自旋量子数为3/2，因此它们的自旋角动量量子数可以取到±3/2、±1/2四个值。这些元素在核磁共振等领域有重要的应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值