java自旋锁的实现及其分析

最新推荐文章于 2024-07-22 17:57:18 发布
置顶 最新推荐文章于 2024-07-22 17:57:18 发布
阅读量650 收藏 1
点赞数
分类专栏： 并发系列 Java系列 文章标签： 多线程 java 链表 队列 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43731074/article/details/105025470
版权

自旋锁是指一个线程尝试获取某个锁时，如果该锁已经被其他线程占用了，就一直循环检测锁释放被释放，而不是像互斥锁一样让线程进入挂起或者睡眠状态。

自旋锁的的缺点就是会一直死循环一直到获取锁为止，这样会一直消耗cpu内存，但是与互斥锁把线程阻塞，然后再次被唤醒相比在性能方面还是有优势的，因为频繁的从用户态切到内核态，需要消耗系统资源，性能也更惨，但是目前的jvm对synchronized实现做了修改采用自旋的到一定次数或者时间就进入阻塞状态，结合了自旋和阻塞，使得目前的synchronized性能大大提高了。

非公平的重入自旋锁的实现过程：

  • 加锁：判断cas中线程是否是当前线程，如果是则计数器+1，如果不是则死循环一直到修改成功(即获取锁成功)，才结束循环

  • 解锁：判断当前获取到锁的线程是否是cas中的线程，如果是则看计数器重入了多少次，如果重入了直接计数器-1，否则直接通过cas修改释放锁。

  • /**
 * @Author:苏牧夕
 * @Date:2020/3/19 23:46
 * @Version 1.0
 */
public class AtoLock {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger();
        System.out.println(atomicInteger.get());
        ThreadPoolExecutor poolExecutor = ThreadPool.InstancePool.poolExecutor;
        SpilLock spilLock = new SpilLock();
//        FairSpilLock spilLock = new FairSpilLock();
        for (int i = 0; i < 5; i++) {
            int x = i;
           poolExecutor.execute(
                    () -> {
                        spilLock.lock();
                        spilLock.lock();
                        try {
                            System.out.println(Thread.currentThread().getName() + x + ",各种骚操作");
                            TimeUnit.SECONDS.sleep(3);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        spilLock.unlock();
                        spilLock.unlock();
                    }
            );
        }
//        System.out.println("操作了几次：" + atomicInteger.get());
        poolExecutor.shutdown();
    }
    static class SpilLock implements Lock {
        private static AtomicReference<Thread> cas = new AtomicReference<>();
        private static AtomicInteger count = new AtomicInteger(0);

        @Override
        public void lock() {
            Thread thread = Thread.currentThread();
            if (thread==cas.get()){
                count.incrementAndGet();
                System.out.println(Thread.currentThread().getName()+"上锁成功");
                return;
            }
            while (!cas.compareAndSet(null, thread)) {
            }
            System.out.println(Thread.currentThread().getName()+"上锁成功");

        }

        @Override
        public void lockInterruptibly() throws InterruptedException {

        }

        @Override
        public boolean tryLock() {
            return false;
        }

        @Override
        public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
            Thread thread = Thread.currentThread();
            Long timeout= unit.toNanos(time);
            if (cas.get()==thread){
                count.incrementAndGet();
                return true;
            }
            Long start = System.nanoTime();
            while (!cas.compareAndSet(null,thread)){
                if (thread.isInterrupted()){
                    thread.interrupt();
                    throw  new InterruptedException();
                }
                long tt=System.nanoTime()-start;
                if (tt>=timeout){
                    return false;
                }
            }
            return true;
        }

        public  void unlock() {
            Thread thread = Thread.currentThread();
            if (thread==cas.get()){
                if (count.get()>0){
            System.out.println(Thread.currentThread().getName()+"解锁成功");
                    count.decrementAndGet();
                }else{
                    if (cas.compareAndSet(thread, null)) {
            System.out.println(Thread.currentThread().getName()+"解锁成功");
                    }
                }
            }
        }

        @Override
        public Condition newCondition() {
            return null;
        }
    }
}

  • 公平自旋锁

    逻辑：

    • 加锁：一个标记记录当前获得锁的编号currNo，然后给每条线程匹配一个编号，如果当前锁编号和当前线程的编号匹配则解锁自旋
    • 解锁：通过cas修改 锁的编号currNo，改为当前获得锁的线程的编号+1
    
static class FairSpilLock implements Lock{
   AtomicInteger currNo = new AtomicInteger(0);
   AtomicInteger threadNo = new AtomicInteger(0);
   ThreadLocal<Integer> local = new ThreadLocal<>();
   AtomicInteger count = new AtomicInteger(0);
       @Override
       public void lock() {
       //生成一个线程编号
           int thNo = threadNo.getAndIncrement();
           //把编号和线程联系起来
           local.set(thNo);
           //自旋当前锁的编号curr释放和当前线程编号一样，如果一样则结束自旋
           while (thNo!=currNo.get()){
               Thread.yield();//如果不是则当前线程礼让，可以不加，加了减少循环次数
           }
           System.out.println(Thread.currentThread().getName()+"加锁成功");

       }

       @Override
       public void lockInterruptibly() throws InterruptedException {

       }

       @Override
       public boolean tryLock() {
           return false;
       }

       @Override
       public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
           return false;
       }

       @Override
       public void unlock() {
       //获取当前线程的编号
           Integer thNo = local.get();
           //cas修改当前锁编号
           if (currNo.compareAndSet(thNo,thNo+1)){
               System.out.println(Thread.currentThread().getName()+"解锁成功！");
           }

       }

       @Override
       public Condition newCondition() {
           return null;
       }
   }

    优点：实现了公平性，使得每条线程都有机会执行

    缺点：每条线/进程都占用处理器在读写标记变量，导致系统性能降低

  • CLH公平自旋锁

    来解决频繁读写标记，就出现了CLH自旋锁算法

    首先简单说一下ThreadLocal这个类的作用，该类负责提供线程都有的本地变量(局部变量),在该类存储的变量，在整个线程存活的过程中可以使用，但是其他线程是无法取的其他线程的局部变量的，类似于一每条线程都有一个私有的Map存储参数，通常使用该类来存储线程的上下文或者id，又因为变量都是线程内部的所以不存在并发问题，所以是线程安全的。

    CLH算法则是利用了ThreadLocal来存储每条线程的节点和它前一条线程的节点作为前继节点，每条线程只自旋判断前继节点的状态，如果前继节点释放锁状态改变，则本线程获取到锁，整个过程在模拟队列，但是该队列是非真实存在的，只是逻辑上是队列，也正是因为通过模拟队列来每条线程有序执行，从而达到公平。

    那么多个线程直接是如何链接起来的呢，首先每条线程都有一个节点用于保存自身的状态是否加锁或者解锁状态，并且存储在ThreahLocal，同时也存储来前一条线程的节点作为，该线程前继节点，那么每条线程是如何获取前一个线程的节点作为前继节点的呢，这里我们需要使用原子引用类来存储尾节点，每条线程创建的时候通过cas操作，把自身作为尾节点，把前一个尾节点作为其前继节点，也就是做，每次有线程申请锁就获取保存了前一条线程节点的尾节点作为其前继节点，这样就把多条线程链接起来，而且还是有序的。

    此外，ThreadLocal容易出现内存泄漏，为什么会出现内存泄漏呢？因为该类内部使用Map存储，而且key继承软引用类，然后value映射起来的，只有内存不足，gc进行垃圾回收就会把软引用回收，也就是key回收了，但是value还在，而且是无法获取的，因为key已经被回收了。

    CLH锁逻辑上是链表形式，所以同样具有很好的扩展性，性能也比较高。

    public class AtoLock {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger();
        System.out.println(atomicInteger.get());
        ThreadPoolExecutor poolExecutor = ThreadPool.InstancePool.poolExecutor;
//        SpilLock spilLock = new SpilLock();
//        FairSpilLock spilLock = new FairSpilLock();
        CLHSpilLock spilLock = new CLHSpilLock();
        for (int i = 0; i < 5; i++) {
            int x = i;
           poolExecutor.execute(
                    () -> {
                        spilLock.lock();
//                        spilLock.lock();
                        try {
                            System.out.println(Thread.currentThread().getName() + x + ",各种骚操作");
                            TimeUnit.SECONDS.sleep(3);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
//                        spilLock.unlock();
                        spilLock.unlock();
                    }
            );
        }
//        System.out.println("操作了几次：" + atomicInteger.get());
        poolExecutor.shutdown();
    }
    static class CLHSpilLock implements Lock{
        CLHSpilLock() {
            tail = new AtomicReference<Node>(new Node());
            //init方法有延迟加载的作用
            prev = new ThreadLocal<Node>(){
                @Override
                protected Node initialValue() {
                    return null;
                }
            };
            currNode = new ThreadLocal<Node>(){
                @Override
                protected Node initialValue() {
                    return new Node();
                }
            };
        }

        static class Node{
            //用于判断前继节点释放释放锁。
            private volatile boolean locked;
        }

        //
       private final ThreadLocal<Node>prev;
        //线程的本地变量(局部变量)，存储自身节点的状态
       private final ThreadLocal<Node>currNode;
       //存储尾节点(也是前一条线程的节点，后一条线程通过这个tail获取前一条线程变量的内存地址并且设置尾前继节点)
       private final  AtomicReference<Node> tail ;


        @Override
        public void lock() {
            //ThreahLocal存储的本地变量(局部变量)，只有线程自己才可以访问到，其他的线程获取不到
            //相当于是线程的私有内存
            //获取当前线程的节点标记。
          final   Node node = currNode.get();
          //设置为当等锁的自旋状态
            node.locked=true;
            //通过cas为节点设置为当前变量，并且获取之前的尾节点作为前继节点
            //这一步是线程之间执行顺序连接起来，preNode是前一条线程的节点，
            Node predNode = tail.getAndSet(node);
            prev.set(predNode);
            //注意CLH，通过把前继节点和自身的节点存存储在ThreadLocal中，
            // 每条线程只根据自己的前继节点释放锁来判断自己释放获取到锁。
            //自旋当前线程节点的前继节点释放已经释放锁，如果释放锁则停止自旋。
            while (predNode.locked){
            }
            System.out.println(Thread.currentThread().getName()+"加锁成功");
        }

        @Override
        public void lockInterruptibly() throws InterruptedException {

        }

        @Override
        public boolean tryLock() {
            return false;
        }

        @Override
        public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
            return false;
        }

        @Override
        public void unlock() {
            //获取线程的私有节点，然后修改状态为false表示释放锁，因为locked使用了volavte修饰，
            //当前节点的状态是下一条线程自旋判断前继节点的状态，因此修改为false时它里面可以发现状态改变，
            // volatilt保证变量在线程之间的可进行
           final Node node = currNode.get();
            node.locked=false;
            //然后把当前节点从本地变量(局部变量)(线程本地内存，反正就是只有自己可以看到的变量)中移除防止内存溢出
            currNode.remove();
            System.out.println(Thread.currentThread().getName()+"释放锁成功");
        }


        @Override
        public Condition newCondition() {
            return null;
        }
    }
  }

    总结：CLH是逻辑上的队列(链表)，并不是真正的队列,而且自旋是自旋前继节点，根据前继节点来判断是否获得锁。

  • MCS公平自旋锁

    MCS算法和CLH算法思路非常相似，但是而且最大的区别是，MCS自旋的是自身节点，而不是前继节点，同时MCS是真正的链表，

    算法思想：每条线程都有一个自身的节点Node（Node存储着线程当前锁的状态和后继节点），存储在线程的局部变量ThreadLocal中，通过一个原子类存储上一次最新申请获取锁的线程的节点称为尾节点，并且后续线程通过cas，获取上一次最后的节点，并且把当前线程节点设置为尾节点，然后把上一次尾节点的后继节点设置为当前节点，然后当前节点进行自旋，那么自旋是如何解锁的呢，这通过解锁过程中，把当前线程节点的后继节点的状态修改为获得锁状态(每次修改后继节点的状态和链表保证了线程执行的有序性)。

    /**
 * @Author:苏牧夕
 * @Date:2020/3/19 23:46
 * @Version 1.0
 */
public class AtoLock {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger();
        System.out.println(atomicInteger.get());
        ThreadPoolExecutor poolExecutor = ThreadPool.InstancePool.poolExecutor;
//        SpilLock spilLock = new SpilLock();
//        FairSpilLock spilLock = new FairSpilLock();
//        CLHSpilLock spilLock = new CLHSpilLock();
        MCSSpilLock spilLock = new MCSSpilLock();
        for (int i = 0; i < 5; i++) {
            int x = i;
            poolExecutor.execute(
                    () -> {
                        spilLock.lock();
//                        spilLock.lock();
                        try {
                            System.out.println(Thread.currentThread().getName() + x + ",各种骚操作");
                            TimeUnit.SECONDS.sleep(3);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
//                        spilLock.unlock();
                        spilLock.unlock();
                    }
            );
        }
//        System.out.println("操作了几次：" + atomicInteger.get());
        poolExecutor.shutdown();
    }

    static class MCSSpilLock implements Lock {
        private final ThreadLocal<Node> curnode;
        private AtomicReference<Node> tail;
        public MCSSpilLock() {
            //第一条线程直接初始化当前节点和尾节点
            this.curnode = new ThreadLocal<Node>() {
                @Override
                protected Node initialValue() {
                    return new Node();
                }
            };
            tail = new AtomicReference<Node>();
        }

        @Override
        public void lock() {
            //获取当前线程局部变量是否已经存在node节点
            Node currNode = curnode.get();
            //线程的节点为null，则创建一个节点
            if (currNode == null) {
                currNode = new Node();
            }
            //然后通过尾插法，先把尾节点取处理，并把当前节点设为尾节点。
            Node predNode = tail.getAndSet(currNode);
            if (predNode != null) {
                //如果不是第一个节点则设置为true,处于等待锁状态
                currNode.locked = true;
                //把前一条线程的节点后继节点设置尾当前节点，保持公平
                predNode.next = currNode;
            }
            //轮询当前节点
            while (currNode.locked) {}
            System.out.println(Thread.currentThread().getName()+"上锁成功");
        }

        @Override
        public void lockInterruptibly() throws InterruptedException {

        }

        @Override
        public boolean tryLock() {
            return false;
        }

        @Override
        public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
            return false;
        }

        @Override
        public void unlock() {
            //获取当前线程的节点
            Node node = curnode.get();
            //如果是最后一个节点则把tail也进行回收。
            if (node.next == null) {
                tail.compareAndSet(node, null);
            }
            //如果有后继线程，则修改状态为获取锁状态。并且把当前节点的引用设置为null
            if (node.next != null) {
                node.next.locked = false;
                node.next = null;
                //回收当前线程的节点。防止内存泄漏
                curnode.remove();
            }
            System.out.println(Thread.currentThread().getName()+"解锁成功");
        }

        @Override
        public Condition newCondition() {
            return null;
        }

        static class Node {
            //false表示获得锁。
            private volatile boolean locked = false;
            private Node next;
        }
    }

    参考CLH和MCS

渐入佳境o
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第07课：基于 Redis 的分布式锁实现及其踩坑案例
Jin_Kwok的博客
10-28 253
分布式锁的实现，目前常用的方案有以下三类： 数据库乐观锁； 基于分布式缓存实现的锁服务，典型代表有 Redis 和基于 Redis 的 RedLock； 基于分布式一致性算法实现的锁服务，典型代表有 ZooKeeper、Chubby 和 ETCD。 基于 Redis 实现分布式锁，网上可以查到很多相关资料，我最初也借鉴了这些资料，但是，在分布式锁的实现和使用过程中意识到这些资料普遍存在问...
Java的自旋锁的实现
jy317358306的博客
03-07 2051
自旋锁是什么： java自旋锁实际上就是死循环获取到代码的执行权限，下面的代码是我仿照着JDK中的AtomicInteger类，自己再编写的一个线程安全的自旋锁的Integer类，并实现了其加法和自增方法 package com.jy.springtest.lock; import sun.misc.Unsafe; import java.lang.reflect.Field; /** * @author jy */ public class MyAutomicInteger { priva
Java锁之自旋锁详解
notOnlyRush的博客
03-31 680
锁作为并发共享数据，保证一致性的工具，在JAVA平台有多种实现(如 synchronized 和 ReentrantLock等等 ) 。这些已经写好提供的锁为我们开发提供了便利，但是锁的具体性质以及类型却很少被提及。本系列文章将分析JAVA下常见的锁名称以及特性，为大家答疑解惑。 1、自旋锁 自旋锁是采用让当前线程不停地的在循环体内执行实现的，当循环的条件被其他线程改变时 才能进入临界区。如下
Java并发（一）CAS自旋锁
最新发布
m0_58466443的博客
07-22 649
4、compareAndSet 方法，这就是实现 CAS 的核心方法了，在使用 AtomicBoolean 的这个方法时，只需要传递期望值和待更新的值即可，而它里面调用了 unsafe.compareAndSwapInt(this, valueOffset, e, u) 方法，它是个 native 方法，用 c++ 实现，具体的代码就不贴了，总之是利用了 CPU 的 cmpxchg 指令完成比较并替换，当然根据具体的系统版本不同，实现起来也有所区别，感兴趣的可以自行搜一下相关文章。否则，返回 false。
java锁之自旋锁
bule_flutter的博客
04-24 336
定义： 自旋锁（spin lock）是一种非阻塞锁，也就是说，如果某线程需要获取锁，但该锁已经被其他线程占用时，该线程不会被挂起，而是在不断的消耗CPU的时间，不停的试图获取锁。线程反复检查锁变量是否可用。由于线程在这一过程中保持执行，因此是一种忙等待。 作用： 自旋锁避免了进程上下文的调度开销。线程一直处于用户态，减少了用户态到内核态的开销与损耗（减少了上下文切换）。 适用场景： 1、多线程 2...
java锁的种类以及辨析——自旋锁
hgh813210的专栏
08-31 550
java锁的种类以及辨析（一）：自旋锁 锁作为并发共享数据，保证一致性的工具，在JAVA平台有多种实现(如 synchronized 和 ReentrantLock等等 ) 。这些已经写好提供的锁为我们开发提供了便利，但是锁的具体性质以及类型却很少被提及。本系列文章将分析JAVA下常见的锁名称以及特性，为大家答疑解惑。 1、自旋锁 自旋锁是采用让当前线程不停地的在循环体内执行
Java自旋锁
viclee
05-05 4397
自旋锁的由来        计算机系统资源总是有限的，有些资源需要互斥访问，因此就有了锁机制，只有获得锁的线程才能访问资源。锁保证了每次只有一个线程可以访问资源。当线程申请一个已经被其他线程占用的锁，就会出现两种情况。一种是没有获得锁的线程会阻塞自己，等到锁被释放后再被唤起，这就是互斥锁；另一种是没有获得锁的线程一直循环在那里看是否该锁的保持者已经释放了锁，这就是自旋锁。   自旋锁的优缺点...
java自旋锁使用_实例讲解Java 自旋锁
weixin_34013327的博客
02-28 1352
一直以来不是怎么清楚自旋锁，最近有点时间，好好的学习了一下；所谓的自旋锁在我的理解就是多个线程在尝试获取锁的时候，其中一个线程获取锁之后，其他的线程都处在一直尝试获取锁的状态，不会阻塞！！！那么什么叫做一直尝试获取锁呢？就是一个循环，比较经典的是AtomicInteger中的一个updateAndGet方法，下图所示(当然也可以直接看unsafe类中的getAndAddInt等类似方法)；我们可以...
java小课堂之线程锁之自旋锁
qf2019的博客
03-15 151
java中定义了非常多的锁，很多同学面试对于锁，感觉非常茫然，于是源码的老师决定，将这些锁拆分开来注意分析讲解，这篇千锋重庆Java培训机构的小编先聊聊自旋锁 自旋锁是基于CAS实现 synchronized重量级锁是基于系统内核 为什么出现自旋锁 jvm发现一个问题，多个线程共享资源的时间片段是及其短暂的，如果为了这点时间片段，我们采用基于系统内核的重量级锁，不断的，挂起线程，唤醒线程是极度的消耗资源的，于是我们就想到，如果那个线程持有共享资源的锁，谁就执行，但是如果有多个线程同时需要执
多核编程笔记——第七章 自旋锁
qq_44951325的博客
03-30 1082
主要讲解了用户态下的自旋锁性能问题。TAS锁，多核TAS锁性能差的原因，解决办法，超时锁
java多线程 锁和Condition总结
许诗宇的博客
02-13 1536
注意：本文参考 java并发编程的艺术 从ReentrantLock的实现看AQS的原理及应用 | JavaGuide 重入锁ReentrantLock ReentrantLock简介 重入锁ReentrantLock, 顾名思义，就是支持重进入的锁，它表示该锁能够支持一个线程对 资源的重复加锁。除此之外，该锁的还支持获取锁时的公平和非公平性选择。 回忆在同步器一节中的示例(Mutex), 同时考虑如下场景当一个线程调用Mutex的lock() 方法获取锁之后，如果再次调用lock()方法...
jvm细节探索之synchronized及实现问题分析
08-28
本文主要探讨了Java中的`synchronized`关键字及其在JVM内部的实现机制。`synchronized`是Java中用于实现线程同步的关键字，它确保了对共享资源的互斥访问，防止数据不一致和竞态条件。 首先，`synchronized`有两种...
面试必备之深入理解自旋锁
weixin_33995481的博客
07-27 3226
分享一个我自己总结的Java学习的系统知识点以及面试问题，目前已经开源，会一直完善下去，欢迎建议和指导欢迎Star： https://github.com/Snailclimb/Java-Guide 本文出自：http://blog.onlycatch.com/post/自旋锁我对原文做了一点补充与修改，我觉得这篇文章写的非常非常好。深...
java 自旋锁实现
weixin_35756892的博客
01-14 530
Java 中可以使用 java.util.concurrent.atomic 包中的 AtomicInteger 类来实现自旋锁。例如： AtomicIntegerlock = new AtomicInteger(1); void acquireLock() { while (!lock.compareAndSet(1, 0)) { // busy wait } ...
Java 中自旋锁的实现
test_touch的专栏
12-28 693
Java中初始是使用mutex互斥锁，因为互斥锁是会线程等待挂起，而对获取锁后的操作时间比较短暂的应用场景来说，这样的锁会让竞争锁的线程不停的park,unpark 的操作，这样的系统的调用性能是非常糟糕的，为了提高锁的性能，java 在6 默认使用了自旋锁。 在Linux中本身就已经提供了自旋锁的系统调用，在glibc-2.9中就有它的比较简单的实现方法 int pthread_sp...
Java中的自旋锁
岁月静好
08-23 1175
思路：每当有线程获取锁的时候，就给该线程分配一个递增的id，我们称之为排队号，同时，锁对应一个服务号，每当有线程释放锁，服务号就会递增，此时如果服务号与某个线程排队号一致，那么该线程就获得锁，由于排队号是递增的，所以就保证了最先请求获取锁的线程可以最先获取到锁，就实现了公平性。可以想象成银行办理业务排队，排队的每一个顾客都代表一个需要请求锁的线程，而银行服务窗口表示锁，每当有窗口服务完成就把自己的服务号加一，此时在排队的所有顾客中，只有自己的排队号与服务号一致的才可以得到服务。
Java实现自定义自旋锁
sui_feng_piao_guo的博客
06-01 5117
自旋锁 1.空轮询实现 此处主要利用while空轮询以及原子包的CAS package com.gy.spinlock; import java.util.concurrent.atomic.AtomicInteger; /** * 利用空轮询实现 */ public class SpinLock01 { private AtomicInteger state = new AtomicInteger(0); public void lock() { whil
java 自旋锁
shine的博客
04-26 2445
一 大纲 1 自旋锁定义 2 自旋锁原理 3 自旋锁时间阈值 4 自旋锁分类 5 自旋锁应用 6 自旋锁开启 二 自旋锁定义 何谓自旋锁？ 它是为实现保护共享资源而提出一种锁机制。其实，自旋锁与互斥锁比较类似，它们都是为了解决对某项资源的互斥使用。无论是互斥锁，还是自旋锁，在任何时刻，最多只能有一个保持者，也就说，在任何时刻最多只能有一个执行单元获得锁。但是...
Java自旋锁深入解析：原理、实现与应用
深入理解Java自旋锁是指在Java编程语言中如何实现自旋锁机制以解决多线程之间的同步问题。自旋锁是一种锁机制，通过不断地循环等待，直到获取到锁才会退出循环。下面我们来详细了解Java自旋锁的实现和工作原理。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值