自旋锁—多种类型的自旋锁实现

最新推荐文章于 2021-02-13 17:08:02 发布
最新推荐文章于 2021-02-13 17:08:02 发布
阅读量1k 收藏 2
点赞数 1
分类专栏： 多线程
原文链接：https://www.jianshu.com/p/824b2e4f1eed
版权

1、简单自旋锁（可重入）

  • 自旋锁是指当一个线程尝试获取某个锁时，如果该锁已被其他线程占用，就一直循环检测锁是否被释放，而不是进入线程挂起或睡眠状态。
  • 自旋锁适用于锁保护的临界区很小的情况，临界区很小的话，锁占用的时间就很短。
package com.mzj.javabase.thread.spinlock.demo2._01_simpledemo;

import com.mzj.javabase.thread.spinlock.demo2.Lock;

import java.util.concurrent.atomic.AtomicReference;

/**
 * 简单自旋锁（可重入）
 *
 */
public class SpinLock implements Lock {
    /**
     *  use thread itself as  synchronization state
     *  使用Owner Thread作为同步状态，比使用一个简单的boolean flag可以携带更多信息
     */
    private AtomicReference<Thread> owner = new AtomicReference<>();
    /**
     * reentrant count of a thread, no need to be volatile
     */
    private int count = 0;

    @Override
    public void lock() {
        Thread t = Thread.currentThread();
        // if re-enter, increment the count.
        if (t == owner.get()) {
            ++count;
            return;
        }
        //spin
        while (owner.compareAndSet(null, t)) {
        }
    }

    @Override
    public void unlock() {
        Thread t = Thread.currentThread();
        //only the owner could do unlock;
        if (t == owner.get()) {
            if (count > 0) {
                // reentrant count not zero, just decrease the counter.
                --count;
            } else {
                // compareAndSet is not need here, already checked
                owner.set(null);
            }
        }
    }
}
  • SimpleSpinLock里有一个owner属性持有锁当前拥有者的线程的引用，如果该引用为null，则表示锁未被占用，不为null则被占用。
  • 这里用AtomicReference是为了使用它的原子性的compareAndSet方法（CAS操作），解决了多线程并发操作导致数据不一致的问题，确保其他线程可以看到锁的真实状态。

本自旋锁缺点：
1、CAS操作需要硬件的配合；
2、保证各个CPU的缓存（L1、L2、L3、跨CPU Socket、主存）的数据一致性，通讯开销很大，在多处理器系统上更严重；
3、没法保证公平性，不保证等待进程/线程按照FIFO顺序获得锁。

2、Ticket Lock

  • Ticket Lock 是为了解决上面的公平性问题，类似于现实中银行柜台的排队叫号：锁拥有一个服务号，表示正在服务的线程，还有一个排队号；每个线程尝试获取锁之前先拿一个排队号，然后不断轮询锁的当前服务号是否是自己的排队号，如果是，则表示自己拥有了锁，不是则继续轮询。
  • 当线程释放锁时，将服务号加1，这样下一个线程看到这个变化，就退出自旋。
package com.mzj.javabase.thread.spinlock.demo2._02_ticketLock;

import com.mzj.javabase.thread.spinlock.demo2.Lock;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * Ticket Lock自旋锁
 */
public class TicketLock implements Lock {
    private AtomicInteger serviceNum = new AtomicInteger(0);
    private AtomicInteger ticketNum = new AtomicInteger(0);
    private final ThreadLocal<Integer> myNum = new ThreadLocal<>();

    @Override
    public void lock() {
        myNum.set(ticketNum.getAndIncrement());
        while (serviceNum.get() != myNum.get()) {
        }
    }

    @Override
    public void unlock() {
        serviceNum.compareAndSet(myNum.get(), myNum.get() + 1);
        myNum.remove();
    }
}

缺点：

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

3、CLHLock自旋锁

  • CLH的发明人是：Craig，Landin and Hagersten。是一种基于链表的可扩展、高性能、公平的自旋锁，申请线程只在本地变量上自旋，它不断轮询前驱的状态，如果发现前驱释放了锁就结束自旋。
  • CLH队列中的结点QNode中含有一个locked字段，该字段若为true表示该线程需要获取锁，且不释放锁，为false表示线程释放了锁。结点之间是通过隐形的链表相连，之所以叫隐形的链表是因为这些结点之间没有明显的next指针，而是通过preNode所指向的结点的变化情况来影响myNode的行为。CLHLock上还有一个尾指针，始终指向队列的最后一个结点。CLHLock的类图如下所示：

  • 一个线程需要获取锁时，会创建一个新的QNode，将其中的locked设置为true表示需要获取锁，然后线程对tail域调用getAndSet方法，使自己成为队列的尾部，同时获取一个指向其前趋的引用preNode,然后该线程就在前趋结点的locked字段上自旋，直到前趋结点释放锁。当一个线程需要释放锁时，将当前结点的locked域设置为false，同时回收前趋结点。如下图所示，线程A需要获取锁，其myNode域为true，些时tail指向线程A的结点，然后线程B也加入到线程A后面，tail指向线程B的结点。然后线程A和B都在它的preNode域上旋转，一旦它的preNode结点的locked字段变为false，它就可以获取锁。明显线程A的preNode locked域为false，此时线程A获取到了锁。

 

 

 

示例代码：

package com.mzj.javabase.thread.spinlock.demo2._03_CLHLock;

import com.mzj.javabase.thread.spinlock.demo2.Lock;

import java.util.concurrent.atomic.AtomicReference;

public class CLHLock implements Lock {

    /**
     * 锁等待队列的尾部
     */
    private AtomicReference<QNode> tail;
    private ThreadLocal<QNode> preNode;
    private ThreadLocal<QNode> myNode;

    public CLHLock() {
        tail = new AtomicReference<>(null);
        myNode = ThreadLocal.withInitial(QNode::new);
        preNode = ThreadLocal.withInitial(() -> null);
    }

    @Override
    public void lock() {
        QNode qnode = myNode.get();
        //设置自己的状态为locked=true表示需要获取锁
        qnode.locked = true;
        //链表的尾部设置为本线程的qNode，并将之前的尾部设置为当前线程的preNode
        QNode pre = tail.getAndSet(qnode);
        preNode.set(pre);
        if(pre != null) {
            //当前线程在前驱节点的locked字段上旋转，直到前驱节点释放锁资源
            while (pre.locked) {
            }
        }
    }

    @Override
    public void unlock() {
        QNode qnode = myNode.get();
        //释放锁操作时将自己的locked设置为false，可以使得自己的后继节点可以结束自旋
        qnode.locked = false;
        //回收自己这个节点，从虚拟队列中删除
        //将当前节点引用置为自己的preNode，那么下一个节点的preNode就变为了当前节点的preNode，这样就将当前节点移出了队列
        myNode.set(preNode.get());
    }

    private class QNode {
        /**
         * true表示该线程需要获取锁，且不释放锁，为false表示线程释放了锁，且不需要锁
         */
        private volatile boolean locked = false;
    }
}
  • CLH队列锁的优点是空间复杂度低（如果有n个线程，L个锁，每个线程每次只获取一个锁，那么需要的存储空间是O（L+n），n个线程有n个myNode，L个锁有L个tail），CLH的一种变体被应用在了JAVA并发框架中。
  • 唯一的缺点是在NUMA系统结构下性能很差，在这种系统结构下，每个线程有自己的内存，如果前趋结点的内存位置比较远，自旋判断前趋结点的locked域，性能将大打折扣，但是在SMP系统结构下该法还是非常有效的。一种解决NUMA系统结构的思路是MCS队列锁。

4、MCSLock自旋锁

  • MCS 来自于其发明人名字的首字母： John Mellor-Crummey和Michael Scott。是一种基于链表的可扩展、高性能、公平的自旋锁，申请线程只在本地变量上自旋，直接前驱负责通知其结束自旋，从而极大地减少了不必要的处理器缓存同步的次数，降低了总线和内存的开销。
package com.mzj.javabase.thread.spinlock.demo2._04_MCSLock;

import com.mzj.javabase.thread.spinlock.demo2.Lock;

import java.util.concurrent.atomic.AtomicReference;

public class MCSLock implements Lock {
    private AtomicReference<QNode> tail;
    private ThreadLocal<QNode> myNode;

    public MCSLock() {
        tail = new AtomicReference<>(null);
        myNode = ThreadLocal.withInitial(QNode::new);
    }

    @Override
    public void lock() {
        QNode qnode = myNode.get();
        QNode preNode = tail.getAndSet(qnode);
        if (preNode != null) {
            qnode.locked = false;
            preNode.next = qnode;
            //wait until predecessor gives up the lock
            while (!qnode.locked) {
            }
        }
        qnode.locked = true;
    }

    @Override
    public void unlock() {
        QNode qnode = myNode.get();
        if (qnode.next == null) {
            //后面没有等待线程的情况
            if (tail.compareAndSet(qnode, null)) {
                //真的没有等待线程，则直接返回，不需要通知
                return;
            }
            //wait until predecessor fills in its next field
            // 突然有人排在自己后面了，可能还不知道是谁，下面是等待后续者
            while (qnode.next == null) {
            }
        }
        //后面有等待线程，则通知后面的线程
        qnode.next.locked = true;
        qnode.next = null;
    }

    private class QNode {
        /**
         * 是否被qNode所属线程锁定
         */
        private volatile boolean locked = false;
        /**
         * 与CLHLock相比，多了这个真正的next
         */
        private volatile QNode next = null;
    }
}

5、CLH锁 与 MCS锁 的比较

差异：

  1. 从代码实现来看，CLH比MCS要简单得多。
  2. 从自旋的条件来看，CLH是在前驱节点的属性上自旋，而MCS是在本地属性变量上自旋。
  3. 从链表队列来看，CLHNode不直接持有前驱节点，CLH锁释放时只需要改变自己的属性；MCSNode直接持有后继节点，MCS锁释放需要改变后继节点的属性。
  4. CLH锁释放时只需要改变自己的属性，MCS锁释放则需要改变后继节点的属性。

 

其他文章待看：https://www.jianshu.com/p/9d3660ad4358?utm_source=oschina-app

https://blog.csdn.net/qq_37909508/article/details/93162296

6、完整工程代码：

https://github.com/mazhongjia/javabase/tree/master/src/main/java/com/mzj/javabase/thread/spinlock

mazhongjia
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++11 自旋锁简单实现
好好学习，天天向上~
11-16 1999
C++11 自旋锁简单实现前言一、自旋锁1.自旋锁实现2.测试 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、自旋锁 1.自旋锁实现 自旋锁简单实现代码如下： class SpinlLock{ atomic_flag flg; public: void lock(){ while(flg
简单介绍 自旋锁SpinLock
weixin_44210395的博客
08-26 335
自旋锁SpinLock什么是自旋锁自旋锁实现 什么是自旋锁 自旋锁 是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁。 优点：减少线程的阻塞以及线程上下文切换的的消耗。常规锁在线程获取不到锁的时候会阻塞挂起，一直等待唤醒，而从挂起到唤醒是需要经过内核态到用户态的相互转换，这样的上下文切换使性能下降。 缺点：循环会消耗CPU。如果线程长期的获取不到锁，那么会一直循环，会消耗CPU。 自旋锁实现 自旋锁的实现需要借助CAS，因为需要通过CAS来判断当前持有锁的线程是否为null或自身。 publ
java 自旋锁实现_java自旋锁的代码实现
weixin_42491621的博客
02-13 355
自旋锁：spinlock是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环好用CPU代码：import java.util.concurrent.TimeUnit;import java.util.concurrent.atomic.AtomicReference;public class SpinLockDemo {//原子引用线程Ato...
Java自旋锁
泷泷养的乔小胖
04-25 2253
1、Java自旋锁理论 自旋锁（spinlock）：是指尝试去获取锁的线程不会立即阻塞，而是采用循环的方式去获取锁，这样的好处是减少线程上下文切换消耗，缺点是循环会消耗CPU。 代码示例： public final int getAndAddInt(Object var1, long var2, int var4) { int var5; do {...
自旋锁代码实现
gaopan1999的博客
03-21 740
class SpinLockdemo{ AtomicReference<Thread> atomicReference = new AtomicReference<>(); public SpinLockdemo(){ } public void myLock(){ Thread thread = Thread.currentThread(); Sy...
Java锁之自旋锁详解
09-04
总的来说，自旋锁在特定场景下可以提高并发程序的效率，但选择哪种类型的自旋锁应根据系统的具体需求和预期的并发行为来决定。在设计和实现并发程序时，理解自旋锁的工作原理及其优缺点是非常关键的。Java提供了多种...
spinlocks:各种自旋锁实现和基准测试
07-06
在`spinlocks-master`这个项目中，可能包含了多种自旋锁的C语言实现和相应的基准测试代码。通过分析和运行这些代码，我们可以对比不同自旋锁的性能，为实际项目选择合适的同步机制提供参考。同时，该项目也可以作为...
基于SMP的Linux内核自旋锁分析.pdf
09-07
"基于SMP的Linux内核自旋锁分析" 本文将对基于SMP...本文对基于SMP的Linux内核自旋锁进行了分析，介绍了自旋锁的概念、实现机制和类型，并分析了Linux内核中自旋锁的实现细节。 关键词：Linux内核；SMP；自旋锁
Linux系统内核的同步机制－自旋锁
03-04
Linux内核提供了多种自旋锁的API，例如： 1. `spin_lock_init(x)`：初始化自旋锁x。 2. `DEFINE_SPINLOCK(x)`：声明并初始化自旋锁x，从2.6.11版本开始引入。 3. `SPIN_LOCK_UNLOCKED`：用于静态初始化一个自旋锁，...
synchronized锁自旋.docx
06-27
总结来说，`synchronized`锁机制在Java中通过多种方式实现了线程同步，包括自旋锁、自适应自旋锁、轻量锁和偏向锁，这些机制在不同程度上减少了锁的开销，提高了并发性能。在实际编程中，了解这些机制有助于编写出...
Linux内核源码之自旋锁的实现
u012603457的博客
10-22 5365
1 Linux内核同步 Linux内核中有许多共享资源，这些共享资源是内核中进程都有机会访问到的。内核对其中一些共享资源的访问是独占的，因此需要提供机制对共享资源进行保护，确保任意时刻只有一个进程在访问共享资源。自旋锁就是一种共享资源保护机制，确保同一时刻只有一个进程能访问到共享资源。 2 普通自旋锁 内核中提供的普通自旋锁API为spin_lock()何spin_unlock()，
自旋锁的C语言代码实现
kunkliu的博客
09-29 5300
上一节主要介绍了 Linux内核中的原子操作，在某种程度上避免了多个线程对同一全局变量的竞争问题。要是内核中的其他C语言程序开发中的临界区都能像上一节介绍的原子变量那样简单就好了。 然而事与愿违，在某个C语言项目中，可能某个临界区甚至会跨越多个函数。例如，函数 A 负责从共享数据结构中取出数据，函数 B 负责处理这些数据，函数 C 则负责将这些数据分发。显然，在这个过程中，要保护共享数据结构，仅仅...
java重入锁 自旋锁_java 自旋锁（可重入且无死锁）
weixin_42110038的博客
02-13 137
java自旋锁 的实现原理：如果自旋锁被另外一个线程对象持有，那么当前获取锁的线程将陷入while循环等待，直到那个持有自旋锁的线程对象释放它所持有的自旋锁，那么那些想要获取该自旋锁的线程对象 将会有一个获得该自旋锁。基于他这种原理，等待的时候，并不释放cpu时间片，相比synchronized wait()操作，减小了释放，重新获取的消耗。 该自旋锁适用于，当前线程竞争不强烈的时候使用。代码：...
C++11实现自旋锁
热门推荐
sharemyfree的专栏
08-07 1万+
http://blog.poxiao.me/p/spinlock-implementation-in-cpp11/ 自旋锁(Spinlock) 自旋锁是一种用于保护多线程共享资源的锁，与一般的互斥锁(mutex)不同之处在于当自旋锁尝试获取锁的所有权时会以忙等待(busy waiting)的形式不断的循环检查锁是否可用。在多处理器环境中对持有锁时间较短的程序来说使用自旋锁代替一般的互斥锁往
Java程序员面试必备之深入理解自旋锁
本人秃顶程序员的博客
05-21 1472
点关注，不迷路；【本人秃顶程序员】持续更新Java架构相关技术及资讯热文！！！ 简单回顾一下CAS算法 CAS算法 即compare and swap（比较与交换），是一种有名的无锁算法。无锁编程，即不使用锁的情况下实现多线程之间的变量同步，也就是在没有线程被阻塞的情况下实现变量的同步，所以也叫非阻塞同步（Non-blocking Synchronization）。CAS算法涉及到三个操作数...
自旋锁
江清月明
03-24 730
以下是我学习自旋锁的一些体会,如果能对您有些帮助,不胜荣耀;如果有哪些错误或不足,请私信我,我会及时进行修改!!!
自旋锁（spinlock） 解释得经典，透彻
wxie的Linux人生
04-03 2612
获得自旋锁和释放自旋锁有好几个版本，因此让读者知道在什么样的情况下使用什么版本的获得和释放锁的宏是非常必要的。 　　如果被保护的共享资源只在进程上下文访问和软中断上下文访问，那么当在进程上下文访问共享资源时，可能被软中断打断，从而可能进入软中断上下文来对被保护的共享资源访问，因此对于这种情况，对共享资源的访问必须使用spin_lock_bh和spin_unlock_bh来保护。 　　当
聊聊高并发（六）实现几种自旋锁（一）
ITer_ZC的专栏
10-22 1万+
在聊聊高并发（五）理解缓存一致性协议以及对并发编程的影响 我们了解了处理器缓存一致性协议的原理，并且提到了它对并发编程的影响，“多个线程对同一个变量一直使用CAS操作，那么会有大量修改操作，从而产生大量的缓存一致性流量，因为每一次CAS操作都会发出广播通知其他处理器，从而影响程序的性能。” 这一篇我们通过两种实现自旋锁的方式来看一下不同的编程方式带来的程序性能的变化。 先理解一
Java并发编程——深入理解自旋锁
dreamchaser533534的博客
09-16 384
1.什么是自旋锁 自旋锁（spinlock）：是指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环。 获取锁的线程一直处于活跃状态，但是并没有执行任何有效的任务，使用这种锁会造成busy-waiting。 2.Java如何实现自旋锁？ 先看一个实现自旋锁的例子，java.util.concurrent包里提供了很多面向并发编程的类. 使用这些类在多核CPU的机器上会有比较好的性能.主要原因是这些类里面大多使用(失败-
Linux内核同步机制解析：中断屏蔽与自旋锁
自旋锁的定义包括两种类型：`raw_spinlock_t` 和 `spinlock_t`。`raw_spinlock_t` 是一个基本的自旋锁结构，包含一个无符号整型变量 `slock` 用于表示锁的状态。`spinlock_t` 则是在 `raw_spinlock_t` 基础上添加了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值