java-锁-自旋锁

最新推荐文章于 2023-08-29 17:10:27 发布
最新推荐文章于 2023-08-29 17:10:27 发布
阅读量121 收藏
点赞数
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zc58778560/article/details/132382918
版权

自旋锁

原理：自旋锁是指当一个线程尝试获取某个锁时，如果该锁已被其他线程占用，就一直循环检测锁是否被释放，而不是进入线程挂起或睡眠状态。

适用：锁保护的临界区很小的情况。

实现：

import java.util.concurrent.atomic.AtomicReference;

public class SpinLock {
    private final AtomicReference<Thread> owner = new AtomicReference<>();

    public void lock() {
        Thread currentThread = Thread.currentThread();
        // 如果锁被占用了会一直重试
        while (!owner.compareAndSet(null, currentThread)) {
        }
    }

    public void unlock() {
        Thread currentThread = Thread.currentThread();
        // 只有持有锁的线程才会成功
        owner.compareAndSet(currentThread, null);
    }
}

缺点：

1、CAS操作需要硬件的配合。

2、保证各个CPU的缓存（L1、L2、L3、跨CPU Socket、主存）一致性，通讯开销很大，在多处理器系统上更严重。

3、没法保证公平性。

排队自旋锁

原理：解决公平性问题，类似银行排队：锁拥有一个服务号，表示正在服务的线程，还有一个排队号；每个线程尝试获取锁之前先拿一个排队号，然后不断轮询锁的当前服务号是否是自己的排队号。当线程释放锁时，将服务号加1，这样下一个线程看到这个变化，就退出自旋。

实现：

import java.util.concurrent.atomic.AtomicInteger;

public class TicketLock {
    private final AtomicInteger serviceNum = new AtomicInteger(); // 表示当前服务号
    private final AtomicInteger ticketNum = new AtomicInteger(); // 用于分发排队号
    private final ThreadLocal<Integer> threadLocal = new InheritableThreadLocal<>(); // 用于线程保存自己的号码

    public void lock() {
        // 拿号
        int myTicketNum = ticketNum.getAndAdd(1);
        // 排队
        while (serviceNum.get() != myTicketNum) {
        }
        // 存号
        threadLocal.set(myTicketNum);
    }

    public void unlock() {
        // 拿出我的号码
        Integer myTicketNum = threadLocal.get();
        if (myTicketNum == null) {
            throw new IllegalStateException("call unlock() before lock()");
        }
        // 更新服务号
        serviceNum.compareAndSet(myTicketNum, myTicketNum + 1);
    }

    // 例子
    public static void main(String[] args) {
        TicketLock lock = new TicketLock();

        Thread t1 = new Thread(() -> {
            lock.lock();
            try {
                System.out.println("t1 get lock");
                Thread.sleep(1000);
                System.out.println("t1 free lock");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }
        });

        Thread t2 = new Thread(() -> {
            lock.lock();
            try {
                System.out.println("t2 get lock");
                Thread.sleep(1000);
                System.out.println("t2 free lock");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }
        });

        t1.start();
        t2.start();
    }
}

缺点：

1、CAS操作需要硬件的配合。

2、每个进程/线程占用的处理器都在读写同一个变量serviceNum，缓存一致性的开销很大。

MCS锁

原理：基于链表的可扩展、高性能、公平的自旋锁，申请线程只在本地变量上自旋，直接前驱负责通知其结束自旋，减少缓存同步的开销。

实现：

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;

public class MCSLock {
    public static class MCSNode {
        volatile MCSNode next;
        volatile boolean isBlock = true; // 默认是在等待锁
    }

    volatile MCSNode queue;// 指向最后一个申请锁的MCSNode
    private static final AtomicReferenceFieldUpdater<MCSLock, MCSNode> UPDATER = AtomicReferenceFieldUpdater
            .newUpdater(MCSLock.class, MCSNode.class, "queue");

    private void lock(MCSNode currentThread) {
        // 获取前驱节点
        MCSNode predecessor = UPDATER.getAndSet(this, currentThread);// step 1
        if (predecessor != null) { // 等待前驱改变我的block状态
            predecessor.next = currentThread;// step 2

            while (currentThread.isBlock) {// step 3
            }
        } else { // 只有一个线程在使用锁，没有前驱来通知它，所以得自己标记自己为非阻塞
            currentThread.isBlock = false;
        }
    }

    private void unlock(MCSNode currentThread) {
        if (currentThread.isBlock) {// 锁拥有者进行释放锁才有意义
            return;
        }

        if (currentThread.next == null) {// 如果自己是最后一个节点，则清理
            if (UPDATER.compareAndSet(this, currentThread, null)) {// step 4
                // compareAndSet返回true表示确实没有人排在自己后面
                return;
            } else {
                // 突然有人排在自己后面了，可能还不知道是谁，下面是等待后续者
                // 这里之所以要忙等是因为：step 1执行完后，step 2可能还没执行完
                while (currentThread.next == null) { // step 5
                }
            }
        }

        currentThread.next.isBlock = false;
        currentThread.next = null;// for GC
    }

    // 封装

    private final ThreadLocal<MCSNode> threadLocal = new InheritableThreadLocal<>();

    public void lock() {
        MCSNode node = new MCSNode();
        lock(node);
        threadLocal.set(node);
    }

    public void unlock() {
        MCSNode node = threadLocal.get();
        if (node == null) {
            throw new IllegalStateException("call unlock() before lock()");
        }
        unlock(node);
    }

    // 例子
    public static void main(String[] args) {
        MCSLock lock = new MCSLock();

        Thread t1 = new Thread(() -> {
            lock.lock();
            lock.lock();
            try {
                System.out.println("t1 get lock");
                Thread.sleep(1000);
                System.out.println("t1 free lock");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }
        });

        Thread t2 = new Thread(() -> {
            lock.lock();
            try {
                System.out.println("t2 get lock");
                Thread.sleep(1000);
                System.out.println("t2 free lock");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }
        });

        t1.start();
        t2.start();
    }
}

CLH锁

原理：基于链表的可扩展、高性能、公平的自旋锁，申请线程只在本地变量上自旋，它不断轮询前驱的状态，如果发现前驱释放了锁就结束自旋。

实现：

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;

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

    private volatile CLHNode tail;
    private static final AtomicReferenceFieldUpdater<CLHLock, CLHNode> UPDATER = AtomicReferenceFieldUpdater.newUpdater(CLHLock.class, CLHNode.class, "tail");

    private void lock(CLHNode currentThread) {
        // 获取前驱节点
        CLHNode preNode = UPDATER.getAndSet(this, currentThread);
        // (1)已有线程占用了锁，进入自旋
        if (preNode != null) {
            while (preNode.isLocked) {
            }
        }
        // (2)没有线程占用锁，直接返回
    }

    private void unlock(CLHNode currentThread) {
        // 如果队列里只有当前线程，则释放对当前线程的引用（for GC）
        if (!UPDATER.compareAndSet(this, currentThread, null)) {
            // (1)还有后续线程
            currentThread.isLocked = false;// 改变状态，让后续线程结束自旋
        }
        // (2)没有后续线程，直接返回
    }

    // 封装

    private final ThreadLocal<CLHNode> threadLocal = new InheritableThreadLocal<>();

    public void lock() {
        CLHNode node = new CLHNode();
        lock(node);
        threadLocal.set(node);
    }

    public void unlock() {
        CLHNode node = threadLocal.get();
        if (node == null) {
            throw new IllegalStateException("call unlock() before lock()");
        }
        unlock(node);
    }

    public static void main(String[] args) {
        CLHLock lock = new CLHLock();
        Thread t1 = new Thread(() -> {
            lock.lock();
            try {
                System.out.println("t1 get lock");
                Thread.sleep(1000);
                System.out.println("t1 free lock");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }
        });
        Thread t2 = new Thread(() -> {
            lock.lock();
            try {
                System.out.println("t2 get lock");
                Thread.sleep(1000);
                System.out.println("t2 free lock");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }
        });
        t1.start();
        t2.start();
    }
}

CLH锁 与 MCS锁 的比较

下图是CLH锁和MCS锁队列图示：

差异：

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

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

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

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

奔跑的飞行兵
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java锁之自旋锁详解
09-04
主要介绍了Java锁之自旋锁详解,本文是系列文章的第一篇,请持续关注脚本之家java栏目,需要的朋友可以参考下
Java自旋锁
埃罗芒阿老师的博客
02-02 1486
Java自旋锁
Java中的自旋锁
岁月静好
08-23 1062
思路：每当有线程获取锁的时候，就给该线程分配一个递增的id，我们称之为排队号，同时，锁对应一个服务号，每当有线程释放锁，服务号就会递增，此时如果服务号与某个线程排队号一致，那么该线程就获得锁，由于排队号是递增的，所以就保证了最先请求获取锁的线程可以最先获取到锁，就实现了公平性。可以想象成银行办理业务排队，排队的每一个顾客都代表一个需要请求锁的线程，而银行服务窗口表示锁，每当有窗口服务完成就把自己的服务号加一，此时在排队的所有顾客中，只有自己的排队号与服务号一致的才可以得到服务。
java学习之锁学习，自旋锁详细讲解
白话机器学习
08-29 1032
自旋锁的定义：当一个线程尝试去获取某一把锁的时候，如果这个锁此时已经被别人获取(占用)，那么此线程就无法获取到这把锁，该线程将会等待，间隔一段时间后会再次尝试获取。这种采用循环加锁 -> 等待的机制被称为自旋锁(spinlock)。此篇文章我们主要讲述了自旋锁的提出背景，自旋锁是为了提高资源的使用频率而出现的一种锁，自旋锁说的是线程获取锁的时候，如果锁被其他线程持有，则当前线程将循环等待，直到获取到锁。自旋锁在等待期间不会睡眠或者释放自己的线程。
轻松搞懂Java中的自旋锁
李长渊的博客
10-08 5498
轻松搞懂Java中的自旋锁
深入理解java自旋锁
08-25
主要介绍了如何深入理解java自旋锁，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，下面和小编来一起学习下吧
一篇文章轻松搞懂Java中的自旋锁
08-26
随着互联网的蓬勃发展，越来越多的互联网...这篇文章主要给大家介绍了关于Java中自旋锁的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Java具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
redis实现分布式锁,自旋式加锁,lua原子性解锁
07-16
redis实现分布式锁,自旋式加锁,lua原子性解锁
Java并发篇乐观锁，悲观锁，自旋锁
06-26
轻量级锁 “轻量级”是相对于使用操作系统互斥量来实现的传统锁而言的。但是，首先需要强调一点的是， 轻量级锁并不是用来代替重量级锁的，它的本意是在没有多线程竞争的前提下，减少传统的重量 级锁使用产生的...
自旋锁
qq_40577921的博客
09-18 313
package com.itjava.interview; import java.security.PublicKey; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicReference; //自旋锁 public class SpinLockDemo { //原子引用...
面试必备之深入理解自旋锁
weixin_33995481的博客
07-27 3193
分享一个我自己总结的Java学习的系统知识点以及面试问题，目前已经开源，会一直完善下去，欢迎建议和指导欢迎Star： https://github.com/Snailclimb/Java-Guide 本文出自：http://blog.onlycatch.com/post/自旋锁我对原文做了一点补充与修改，我觉得这篇文章写的非常非常好。深...
java 自旋锁
ai_xiangjuan的博客
05-30 860
1.介绍 从jdk1.5 后java实现了各种锁优化技术，如适应性自旋、锁消除、锁粗化、轻量级锁和偏向锁等。 2.自旋锁与自适应锁 2.1 为什么需要自旋锁 在互斥实现的时候，互斥同步对性能最大的影响是阻塞的实现，挂起线程和恢复线程的操作都需要转入内核态完成。这些操作给系统的并发性能带来了很大的压力。 在现实中，很多共享数据的锁定状态只会持续很短的一段时间，为了这段时间去挂起和恢复线...
简单Java自旋锁
一叶一菩提的博客
09-14 382
1.什么是自旋锁 自旋锁（spin lock）是一种非阻塞锁，也就是说，如果某线程需要获取锁，但该锁已经被其他线程占用时，该线程不会被挂起（在哪循环），而是在不断的消耗CPU的时间，不停的试图获取锁。 2.什么时候用自旋锁 自旋锁就主要用在临界区持锁时间非常短且CPU资源不紧张的情况下，自旋锁一般用于多核的服务器。 Java 实现 简单可重入自旋锁 public class SpinLock implements Lock { /** * use thread itself as sy
Java的自旋锁的实现
jy317358306的博客
03-07 2015
自旋锁是什么： 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中的自旋锁的实现
csucoderlee的专栏
08-07 2万+
什么是自旋锁 多线程中，对共享资源进行访问，为了防止并发引起的相关问题，通常都是引入锁的机制来处理并发问题。 获取到资源的线程A对这个资源加锁，其他线程比如B要访问这个资源首先要获得锁，而此时A持有这个资源的锁，只有等待线程A逻辑执行完，释放锁，这个时候B才能获取到资源的锁进而获取到该资源。 这个过程中，A一直持有着资源的锁，那么没有获取到锁的其他线程比如B怎么办？通常就会有两种方式： 1...
java 中的锁 -- 偏向锁、轻量级锁、自旋锁、重量级锁
热门推荐
zqz_zqz的博客
04-19 14万+
之前做过一个测试，详情见这篇文章《多线程 +1操作的几种实现方式，及效率对比》，当时对这个测试结果很疑惑，反复执行过多次，发现结果是一样的: 1. 单线程下synchronized效率最高（当时感觉它的效率应该是最差才对）； 2. AtomicInteger效率最不稳定，不同并发情况下表现不一样：短时间低并发下，效率比synchronized高，有时甚至比LongAdder还高出一点，但是...
java 自旋锁实现
最新发布
09-13
### 回答1： Java 中可以使用 `java.util.concurrent.atomic` 包中的 `AtomicInteger` 类来实现自旋锁。例如： ``` AtomicInteger lock = new AtomicInteger(1); void acquireLock() { while (!lock.compareAndSet(1, 0)) { // busy wait } } void releaseLock() { lock.set(1); } ``` 这里的自旋锁使用了 Java 的原子变量来实现，通过调用 `compareAndSet` 方法来获取锁，当锁可用时，该方法会将锁的值从 1 更改为 0，并返回 true，否则返回 false。在释放锁时，只需要将锁的值设置为 1 即可。 ### 回答2： 自旋锁是一种线程同步的机制，常用于多线程环境下保护临界区。它可以避免线程的频繁切换，提高程序的执行效率。 Java中自旋锁的实现通常使用了volatile关键字和CAS（Compare And Swap）机制。下面是一种简单的自旋锁实现示例： ```java public class SpinLock { private volatile boolean locked = false; public void lock() { // 使用CAS操作尝试将locked变量从false修改为true while (!compareAndSet(false, true)) { // locked为true时，说明锁已经被其他线程获取，当前线程进入自旋等待 Thread.yield(); } } public void unlock() { // 释放锁，将locked变量设为false locked = false; } private boolean compareAndSet(boolean expect, boolean update) { // 使用CAS操作设置locked变量的值 return Unsafe.getUnsafe().compareAndSwapBoolean(this, lockedOffset, expect, update); } } ``` 这里的locked变量使用volatile修饰，保证了线程间的可见性。lock()方法中，使用CAS操作尝试将locked变量从false修改为true，如果成功表示获取了锁，否则进入自旋等待。在unlock()方法中，将locked变量设为false，释放锁。 需要注意的是，自旋锁适用于临界区的执行时间很短的情况，如果临界区执行时间较长，存在大量的自旋等待，会浪费CPU资源，此时应该使用其他的同步机制，如互斥锁。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值