解析自旋锁CAS

最新推荐文章于 2024-04-12 14:49:49 发布
最新推荐文章于 2024-04-12 14:49:49 发布
阅读量1.3k 收藏 2
点赞数
分类专栏： 多线程 文章标签： java 多线程 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guanzhi128/article/details/108694097
版权

前置知识Java 内存模型中的可见性、原子性和有序性

可见性：

可见性，是指线程之间的可见性，一个线程修改的状态对另一个线程是可见的。也就是一个线程修改的结果。另一个线程马上就能看到。比如：用volatile修饰的变量，就会具有可见性。volatile修饰的变量不允许线程内部缓存和重排序，即直接修改内存。所以对其他线程是可见的。但是这里需要注意一个问题，volatile只能让被他修饰内容具有可见性，但不能保证它具有原子性。比如 volatile int a = 0；之后有一个操作 a++；这个变量a具有可见性，但是a++ 依然是一个非原子操作，也就是这个操作同样存在线程安全问题。

在 Java 中 volatile、synchronized 和 final 实现可见性。

原子性：

原子是世界上的最小单位，具有不可分割性。比如 a=0；（a非long和double类型） 这个操作是不可分割的，那么我们说这个操作时原子操作。再比如：a++；这个操作实际是a = a + 1；是可分割的，所以他不是一个原子操作。非原子操作都会存在线程安全问题，需要我们使用同步技术（sychronized）来让它变成一个原子操作。一个操作是原子操作，那么我们称它具有原子性。java的concurrent包下提供了一些原子类，我们可以通过阅读API来了解这些原子类的用法。比如：AtomicInteger、AtomicLong、AtomicReference等，JDK1.8之后的LonAddr,DoubleAddr提供的分片操作等。

在 Java 中 synchronized 和在 lock、unlock 中操作保证原子性。

有序性：

Java 语言提供了 volatile 和 synchronized 两个关键字来保证线程之间操作的有序性，volatile 是因为其本身包含“禁止指令重排序”的语义，synchronized 是由“一个变量在同一个时刻只允许一条线程对其进行 lock 操作”这条规则获得的，此规则决定了持有同一个对象锁的两个同步块只能串行执行。

当对非 volatile 变量进行读写的时候，每个线程先从内存拷贝变量到CPU缓存中。如果计算机有多个CPU，每个线程可能在不同的CPU上被处理，这意味着每个线程可以拷贝到不同的 CPU 中。经典的i++问题不是线程安全，

而声明变量是 volatile 的，JVM 保证了每次读变量都从内存中读。

在这里插入图片描述

volatile
保证线程可见性
– MESI

– 缓存一致性协议

禁止指令重排序（CPU）
– DCL单例

– Double Check Lock

-- loadfence 原语指令

-- storefence 原语指令

单例模式-饿汉式

 /**
 * 饿汉式
 * 类加载到内存后，就实例化一个单例，JVM保证线程安全
 * 缺点：不管用到与否，类加载时就完成实例化，不用的类，加载了干啥
 */
public class VolatileSingle {
    private static final  VolatileSingle instance = new VolatileSingle();

    private VolatileSingle(){

    }

    private static VolatileSingle getInstance(){
        return instance;
    }

    public static void main(String[] args) {
        VolatileSingle single1 = VolatileSingle.getInstance();
        VolatileSingle single2 = VolatileSingle.getInstance();
        System.out.println(single1 == single2);
    }
}

懒汉式

/*
 * 懒汉式
 * 默认不会实例化，什么时候用什么时候
 * 虽然达到了按需初始化的目的，但也带来了线程不安全的问题
 */
public class VolatileSingle1 {
    private static VolatileSingle1 instance;

    private VolatileSingle1(){

    }

    private static VolatileSingle1 getInstance(){
        if (instance == null){
            try {
                Thread.sleep(1);
            }catch (InterruptedException interruptedException){
                interruptedException.printStackTrace();
            }
            instance = new VolatileSingle1();
        }
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0 ; i < 100 ; i++){
            new Thread(() ->{
                System.out.println(VolatileSingle1.getInstance().hashCode());
            }).start();
        }
    }
}

输出结果：

2068895579
48238505
120111935
875048040
2077358326
95324150
2077358326
1419457248
1641419305
1419457248
1419457248
1944532174
1316704413
2007045553
1641419305
1557134983
1557134983
993945018
176261066
1955884916
2048417961
1526685889
1788262330
786680875
2077358326
2077358326
2077358326

懒汉式 — 方法加锁

 /*
 * 懒汉式 --方法加锁，
 * 默认不会实例化，什么时候用什么时候
 * 虽然达到了按需初始化的目的，但也带来了线程不安全的问题
 * 虽然可以通过synchronized方法上锁解决，但也带来了效率下降
 */
public class VolatileSingle2 {
    private static VolatileSingle2 instance;

    private VolatileSingle2(){

    }

    private static synchronized VolatileSingle2 getInstance(){
        if (instance == null){
            try {
                Thread.sleep(1);
            }catch (InterruptedException interruptedException){
                interruptedException.printStackTrace();
            }
            instance = new VolatileSingle2();
        }
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0 ; i < 100 ; i++){
            new Thread(() ->{
                System.out.println(VolatileSingle2.getInstance().hashCode());
            }).start();
        }
    }
}

懒汉式—代码块加锁/**

 /* 
 * 懒汉式 --代码块加锁，
 * 默认不会实例化，什么时候用什么时候
 * 虽然达到了按需初始化的目的，但也带来了线程不安全的问题
 * 虽然可以通过synchronized方法上锁解决，但也带来了效率下降
 */
public class VolatileSingle3 {
    private static VolatileSingle3 instance;

    private VolatileSingle3(){

    }

    private static synchronized VolatileSingle3 getInstance(){
        if (instance == null){
            //通过同步代码块的方式来提高效率
            //存在问题：第一个线程过来判断为空，还未执行，线程二来也判断为空，第一个线程上锁，初始化完返回，线程二此时也是空的，也会初始化一遍再返回
            synchronized (VolatileSingle3.class){
                try {
                    Thread.sleep(1);
                }catch (InterruptedException interruptedException){
                    interruptedException.printStackTrace();
                }
                instance = new VolatileSingle3();
            }
        }
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0 ; i < 1000 ; i++){
            new Thread(() ->{
                System.out.println(VolatileSingle3.getInstance().hashCode());
            }).start();
        }
    }
}

DCL— Double Check Lock(双重校验锁)

/**
 * 懒汉式 --双重锁校验，
 * 默认不会实例化，什么时候用什么时候
 * 虽然达到了按需初始化的目的，但也带来了线程不安全的问题
 * 虽然可以通过synchronized方法上锁解决，但也带来了效率下降
 */
public class VolatileSingle4 {
    //关于是否需要加上volatile，不加volatile，问题会出现在指令重排序上
    //new 一个对象会分成3步：1、申请内存；2、更新值；3赋值给对象；
    //若不加volatile，在超高超高的并发情况下，会产生对象在半初始化的时候就指令有可能被打断而重新排序，线程1初始化一半时，线程2到来，取到了半初始化的值
    // synchronized是保证了可见性，但不能阻止重排序
    private static volatile VolatileSingle4 instance;

    private VolatileSingle4(){

    }

    private static synchronized VolatileSingle4 getInstance(){
        if (instance == null){
            //双重检查
            synchronized (VolatileSingle4.class){
                //上锁之后再次进行加锁
                if (instance == null){
                    try {
                        Thread.sleep(1);
                    }catch (InterruptedException interruptedException){
                        interruptedException.printStackTrace();
                    }
                    instance = new VolatileSingle4();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0 ; i < 1000 ; i++){
            new Thread(() ->{
                System.out.println(VolatileSingle4.getInstance().hashCode());
            }).start();
        }
    }
}

volatile能否替代synchronized

/**
 * volatile 并不能保证多线程共同修改running变量时所带来的不一致问题，也就是说volatile不能替代synchronized
 * count++线程不安全，非原子性操作
 */
public class T {
    volatile int count = 0;


    //操作时需要加上锁
    /**synchronized*/ void m() {
        for (int i = 0; i < 10000; i++) {
            count++;
        }
    }
    public static void main(String[] args) {
        T t = new T();
        List<Thread> threadList = new ArrayList<>();

        for (int j = 0; j < 10; j++) {
            threadList.add(new Thread(t::m,"thread-" + j));
        }

        threadList.forEach((o) -> o.start());

        threadList.forEach((o) ->{
            try {
                o.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(t.count);
    }
}

锁优化

 /**
 * synchronized优化
 * 同步代码块中的语句越少越好-----锁细化
 * 锁争用的时候，可以考虑锁粗化
 * 比较m1和m2
 */
public class FineCoarseLock {
  
   int count = 0;

   synchronized void m1() {
      //do sth need not sync
      try {
         TimeUnit.SECONDS.sleep(2);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
      //业务逻辑中只有下面这句需要sync，这时不应该给整个方法上锁
      count ++;
      
      //do sth need not sync
      try {
         TimeUnit.SECONDS.sleep(2);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
   }
  
   void m2() {
      //do sth need not sync
      try {
         TimeUnit.SECONDS.sleep(2);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
      //业务逻辑中只有下面这句需要sync，这时不应该给整个方法上锁
      //采用细粒度的锁，可以使线程争用时间变短，从而提高效率
      synchronized(this) {
         count ++;
      }
      //do sth need not sync
      try {
         TimeUnit.SECONDS.sleep(2);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
   }
}

CAS(无锁化，自旋）

–Compare And Set
–cas(V, Expected, NewValue)

-if V == E 若所期望的值相同

V = NEW      则设置成新的值

try again or fail   反之这重试或者直接失败
  • CPU 原语支持(执行过程中不能被打断)
  • ABA问题 采用加version解决（基础类型–可以不用考虑，引用类型—会通俗来讲就是你大爷还是你大爷，你大妈已经不是你大妈了_）

java.util.concurrent.atomic.目录下以Atomic开头的都是自旋锁，JDK1.8之后提拱了分片区自旋锁，LongAddr、DoubleAddr等

/**
 * 解决同样的问题的更高效的方法，使用AtomXXX类
 * AtomXXX类本身方法都是原子性的，但不能保证多个方法连续调用是原子性的
 */
public class T_AtomicInteger {  
   AtomicInteger count = new AtomicInteger(0);

   /*synchronized*/ void m() {
      for (int i = 0; i < 10000; i++)
         count.incrementAndGet();
   }

   public static void main(String[] args) {
      T_AtomicInteger t = new T_AtomicInteger();

      List<Thread> threads = new ArrayList<Thread>();

      for (int i = 0; i < 10; i++) {
         threads.add(new Thread(t::m, "thread-" + i));
      }

      threads.forEach((o) -> o.start());

      threads.forEach((o) -> {
         try {
            o.join();
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      });
      System.out.println(t.count);
   }
}

Unsafe

在这里插入图片描述
在这里插入图片描述
随手点个关注~

mrz092
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解CAS (自旋锁)
流楚丶格念的博客
07-23 5063
CAS,compareandswap的缩写，中文翻译为比较并交换。CAS操作中包含三个操作数——内存位置(V)、预期原值(E)和新值(N)。这三个字母缩写的含义Variable变量；Expect预期；New新如果内存位置的值与预期原值相匹配，那么处理器会⾃动将该位置值更新为新值。否则，处理器不做任何操作。⽆论哪种情况，它都会在CAS指令之前返回该位置的值(在CAS的⼀些特殊情况下将仅返回CAS是否成功，而不提取当前值)。CAS用同步的方式。...
我们常说的 CAS 自旋锁是什么
weixin_33967071的博客
05-10 334
CAS（Compare and swap），即比较并交换，也是实现我们平时所说的自旋锁或乐观锁的核心操作。 它的实现很简单，就是用一个预期的值和内存值进行比较，如果两个值相等，就用预期的值替换内存值，并返回 true。否则，返回 false。 保证原子操作 任何技术的出现都是为了解决某些特定的问题， CAS 要解决的问题就是保证原子操作。原子操作是什么，原子就是最小不可拆分的，原子操作就是最小...
【并发】 第五篇 原子操作(二) - CAS 详解
最新发布
入坑太深起不来
04-12 819
CAS是"比较并交换"（Compare and Swap）的缩写。是一种并发控制机制，用于实现多个线程同时对同一数据进行原子操作（读取、写入、更新），并且能够保证操作的一致性。# 1.比较：通过比较当前值和期望值是否一致来判断是否修改成功# 2.交换：如果一致则修改，否则重新尝试。CAS的一种常见应用是实现乐观锁。在乐观锁机制中，线程在更新共享变量之前先检查该变量是否被其他线程修改过，如果没有修改则更新，否则重新尝试。CAS操作正是基于这个原理来实现的。
CAS自旋锁浅析
weixin_44457062的博客
02-24 1165
CAS自旋锁浅析 前提： 了解 JMM（Java内存模型），链接：JMM(Java内存模型)浅记 了解volatile和synchronized关键字 volatile关键字： 保证了可见性 不保证原子性 保证了有序性（通过屏障来防止指令重排，来实现 JMM 规范的有序性） synchronized关键字： 保证了可见性 保证了原子性 保证了有序性（通过限制每次只能一个线程执行操作，来实现 JMM 规范的有序性） 注意： 虽然 volatile 和 synchronized 都实现了 JMM 规范的
CAS和自旋锁
weixin_40017062的博客
04-19 4214
1、CAS：Compare And Swap即比较并替换，先检查旧值一致后才会替换。 2、CAS自旋锁：指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待获取，直到获取到锁才会退出循环。 3、原子操作类：AtomicInteger、AtomicLong、AtomicBoolean、AtomicReference 4、CAS机制ABA问题.........
cas自旋锁
贺天远 廊坊师范学院信息技术提高班十五期
05-29 452
cas的全称为compare and swap，比较和替换，是一种无锁状态的锁。该锁的实现机制是，当我们需要改一个对象的值的时候，我们会先获取到该值并通过算法生成一个新的值，然后我们去查看当前变量的新值（重新获取一次变量的值）与期望值是否相等（期望值是我们期望变量没有发生改变），如果相等，则不能将新值赋值给此变量，并重新执行算法，重新判断。如果未发生改变则将新值赋值给变量。 如下图所示（新值N是第二次读取变量的值，E为第一次读取变量的值，判断两个值是否发生变化从而判断变量是否被其他线程修改过，如果值发生变化
MarkWord 锁标记1
08-03
本篇文章将详细解析MarkWord中的锁状态以及其在不同锁模式下的特点和应用场景。 首先，MarkWord由56位组成，分为以下几个部分： 1. **锁状态**：1位表示是否为偏向锁，1位表示锁标志位。这两位共同决定了锁的当前...
java锁机制详解.pdf
10-04
- **轻量级锁**：如果线程在执行过程中遇到其他线程竞争，会升级为轻量级锁，使用CAS操作尝试获取锁，避免重量级锁的系统调用开销。 - **自旋锁**：如果线程在尝试获取锁时发现锁已被占用，但很快就会释放，线程会...
Java并发工具类LongAdder原理实例解析
08-19
AtomicLong使用CAS（Compare-And-Swap）操作来更新计数器，但是当多个线程同时更新同一个变量时，会导致大量线程CAS失败，处于自旋状态，浪费CPU资源，降低并发性。 LongAdder的设计思想是将一个变量分解为多个变量...
2.Java7_8+中的+HashMap+和+ConcurrentHashMap+全解析1
08-04
ConcurrentHashMap在Java 8中也进行了优化，取消了分段锁，改用ForkJoinPool和CAS操作，实现更为细粒度的并发控制，进一步提升了并发性能。 对于Java 8的ConcurrentHashMap，其内部结构更为复杂，使用了Node节点...
ioking真正无锁的服务器引擎之消息引擎模块（nolock）
08-27
然而，CAS操作在高并发下可能会导致自旋锁，消耗大量的CPU资源。ioking消息引擎模块摒弃了CAS，通过其他机制确保数据一致性，降低了CPU争用，优化了性能。 再者，提到“非lock-free”，通常lock-free算法利用硬件...
深入讲解我们说的CAS自旋锁到底是什么
08-27
主要给大家介绍了关于我们说的CAS自旋锁到底是什么的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java-类与类之间的相互调用
lonewolfh的博客
05-05 1808
方法1 新建一个类，然后在调用类中先将其实例化，然后通过实例化的对象访问 如： 先定义一个类 public class Vehicle { public void run(){ System.out.println("跑得快！"); } } 再实例化，调用 public class Test { public static void main(String[] args) { Vehicle ve=new Vehic.
CAS自旋锁，看这一篇就够了
梵高
07-07 3365
《最伟大的作品》让我们穿越到1920年，见到了马格利特的绿苹果、大利的超现实、常玉画的大腿、莫奈的睡莲、徐志摩的诗…他说“最伟大的作品”并不是自己的歌，而是这个世界上最伟大的艺术作品们。............
《利用CAS实现自旋锁》
weixin_43766298的博客
07-04 484
利用CAS实现自旋锁1.编写自旋锁2.测试自旋锁 1.编写自旋锁 import java.util.concurrent.atomic.AtomicBoolean; //自旋锁 public class SpinLock { //CAS private AtomicBoolean cas = new AtomicBoolean(false); //锁持有者线程 private Thread spinLockOwnerThread = null; public voi
【锁思想】自旋 与 CAS 它俩性质真的一样吗？一篇带你搞懂
wdj_yyds的博客
07-08 1654
本篇文章主要围绕自旋和CAS来展开介绍，主要介绍了他们俩的区别，对于锁来讲自旋的思想给程序带来的性能提升，以及在Java中CAS和自旋的适用场景等，这里就不再赘述了。
java怎么调用同包变量,Java并发包中的原子变量操作类
weixin_42336364的博客
03-10 184
JUC并发包提供了一系列的原子操作类，这些类都是使用非阻塞算法(CAS)实现的，相比于使用锁来实现，这些原子操作类在性能上更好一些。JUC并发包中包含有AtomicInteger、AtomicLong和AtomicBoolean等原子性操作类，它们的原理相似。这里以AtomicLong为例进行说明，AtomicLong是原子性递增或者递减类，它是使用Unsafe来实现的。AtomicLong通过C...
compareAndSet(CAS, 自旋锁)理解
热门推荐
sanding的博客
12-13 2万+
背景 CAS？ 自旋是什么意思？ CAS是怎么保证原子性操作的？ CAS带来的ABA问题，及解决方案？ 过程 CAS compareAndSet，compareAndExchange，compareAndSwap 这个函数会先进行比较，如果相比较的两个值是相等的，那么就进行更新操作。 CAS使用场景 AtomicInteger atomicInteger = new AtomicInteger(1); atomicInteger.compareAndSet(1, 2); 初始值是1 compar
cas实现原理, 自旋锁机制
05-20
CAS（Compare and Swap）是一种原子操作，用于实现多线程环境下的同步。其基本思想是，先比较内存中的值和一个期望值，如果相等则将一个新值写入内存中，否则不做任何操作。 自旋锁是一种基于CAS的锁实现，当线程尝试获取锁时，如果发现锁已经被其他线程持有，则不会立即阻塞，而是通过不断地重试获取锁，直到获取到锁为止。 自旋锁的实现原理如下： 1. 定义一个原子变量state，用于表示锁的状态，0表示未锁定，1表示已锁定； 2. 线程尝试获取锁时，先使用CAS操作将state从0改为1，如果成功，则获取锁成功； 3. 如果CAS操作失败，则说明锁已被其他线程持有，此时线程不会立即阻塞，而是通过不断地重试获取锁； 4. 当线程释放锁时，将state重新设置为0。 自旋锁适用于锁竞争时间短暂的情况，如果锁竞争时间较长，则自旋锁会导致CPU资源的浪费。因此，在实际应用中，需要根据具体情况选择合适的锁实现方式。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值