java并发编程学习六——乐观锁CAS

已于 2022-09-23 15:53:01 修改
阅读量604 收藏 1
点赞数 1
分类专栏： java并发编程 文章标签： java jvm
于 2022-09-22 14:54:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yx444535180/article/details/126931257
版权

文章目录

一、CAS原理

CAS全称CompareAndSet或者CompareAndSwap，其中【比较-交换】的操作是原子的，下面先一个具体的案例

1.1 无锁保护共享变量

定义一个接口

interface Acount {

    void withdraw(int amount);

    Integer getBalance();
	//设置余额为10000，一千个线程每个线程减少10，正确结果应该为0
    static void demo(Acount acount) {
        List<Thread> threadList = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            threadList.add(new Thread(() -> acount.withdraw(10)));
        }
        long start = System.currentTimeMillis();
        threadList.forEach(Thread::start);

        threadList.forEach(thread -> {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.currentTimeMillis();
        
        System.out.printf("执行时间：%d，余额：%d", end - start, acount.getBalance());
    }
}

1.1.1 不安全模式实现

不安全的实现

class AcountUnsafe implements Acount {
    private Integer balance;

    public AcountUnsafe(Integer balance) {
        this.balance = balance;
    }

    @Override
    public void withdraw(int amount) {
        this.balance -= amount;
    }

    public Integer getBalance() {
        return balance;
    }

    public void setBalance(Integer balance) {
        this.balance = balance;
    }
}

测试

public class Test1 {
    public static void main(String[] args) {
        Acount acount = new AcountUnsafe(10000);
        Acount.demo(acount);
    }
}

结果：
在这里插入图片描述

1.1.2 有锁安全实现

给withdraw加锁即可

 @Override
    public void withdraw(int amount) {
        synchronized(this){
            this.balance -= amount;
        }
    }

结果：
在这里插入图片描述

1.1.3 无锁安全实现

无锁采用原子整数AtomicInteger来实现

class AcountSafe implements Acount {
    private AtomicInteger balance;

    public AcountSafe(AtomicInteger balance) {
        this.balance = balance;
    }

    @Override
    public void withdraw(int amount) {
        while (true) {
            int prev = this.balance.get();
            int value = prev - amount;
            // compareAndSet是JVM提供的本地方法，该方法具有原子性
            if (this.balance.compareAndSet(prev, value)) {
                break;
            }
        }
    }

    public Integer getBalance() {
        return balance.get();
    }

}

结果
在这里插入图片描述
比较执行时间发现，无锁比有锁实现要快一点

1.2 CAS工作方式

先分析下上述代码的时序图
在这里插入图片描述
CAS底层使用的lock compxchg指令（X86架构），在单核CPU和多核CPU下都能保证【比较-交换】的原子性。CAS必须借助volatile才能读到共享变量的最新值，从而完成【比较-交换】的效果，来看看AtomicInteger的源码，其中初始值value就是用volatile修饰的
在这里插入图片描述
注意，volatile只能保证可见性，让其他线程看到最新值，但不能保证原子性即不能解决多个线程的指令交错问题。

1.3 CAS的效率和特点

CAS的作用是用无锁来实现多线程对共享变量操作的安全性，由于需要不停重试它也不是一定能提高效率。
CAS的效率：

  • 无锁的情况下，即使重试失败，线程仍然在高速运行。synchronized加锁会让线程进入阻塞，发生上下文切换。
  • 线程上下文切换，好比赛车在跑动高速运行时，需要先刹车减速停下之后再被唤醒之后重新启动、加速，代价比较大。
  • 无锁情况下，线程要保持运行，需要CPU支援。在单核CPU下，线程不加锁也会由于时间片使用完，发生上下文切换。因此，CAS需要在多核下才能发挥优势，而且线程数最好不要超过CPU核数。

CAS的特点：

  • CAS基于乐观锁的思维实现，不怕别人修改共享变量，修改了没关系，自己再重试
  • synchronized基于悲观锁的思维，加锁之后不允许别人修改共享变量，除非自己修改完释放锁，别人才有机会
  • CAS体现的是无锁并发、无阻塞并发。由于没有加锁，不会发生阻塞，从而提高效率。但是在竞争激烈的情况下，会发生大量的无效重试，反而会影响效率。

二、原子整数

2.1 AtomicInteger、AtomicBoolean、AtomicLong

AtomicInteger、AtomicBoolean、AtomicLong，这三个比较类似，都可以看做是对一个整数的封装。

public class AtomicIntegerTest {
    public static void main(String[] args) {
        AtomicInteger i = new AtomicInteger(0);
        //自增等价于++i
        System.out.println(i.incrementAndGet());
        //i++
        System.out.println(i.getAndIncrement());
        System.out.println(i.get());
        //类似的还有--i，i--

        //增加指定的数
        System.out.println(i.addAndGet(3));
        System.out.println(i.getAndAdd(3));
        System.out.println(i.get());

        //其他计算，乘法等复杂运算
        System.out.println(i.updateAndGet(x -> x * 2 - 1));
        System.out.println(i.getAndUpdate(x -> x * 2 - 1));
        System.out.println(i.get());

        //自己实现updateAndGet
        System.out.println(updateAndGet(i,x->(x-1)*2));
    }

    private static AtomicInteger updateAndGet(AtomicInteger i, IntUnaryOperator intUnaryOperator) {
        int prev;
        do {
            prev = i.get();
        } while (!i.compareAndSet(prev, intUnaryOperator.applyAsInt(prev)));
        return i;
    }
}

2.2 Unsafe模拟AtomicInteger

public class MyAtomicIntegerTest implements Acount {

    public static void main(String[] args) {
        Acount test = new MyAtomicIntegerTest(10000);
        Acount.demo(test);
    }

    MyAtomicInteger balance;

    public MyAtomicIntegerTest(int i) {
        this.balance = new MyAtomicInteger(i);
    }

    @Override
    public void withdraw(int amount) {
        balance.incrementAndGet(-amount);
    }

    @Override
    public Integer getBalance() {
        return balance.get();
    }
}

class MyAtomicInteger {
    volatile int value;

    private static Unsafe UNSAFE;

    private static long valueOffset;

    static {
        try {
            //利用反射获取Unsafe的实例
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            UNSAFE = (Unsafe) field.get(null);
            //获取字段value相对类对象内存开始位置的偏移量
            valueOffset = UNSAFE.objectFieldOffset(MyAtomicInteger.class.getDeclaredField("value"));
        } catch (NoSuchFieldException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public MyAtomicInteger(int value) {
        this.value = value;
    }

    public int get() {
        return value;
    }

    public void incrementAndGet(int i) {
        while (true) {
            if (UNSAFE.compareAndSwapInt(this, valueOffset, this.get(), this.get() + i)) {
                break;
            }
        }
    }
}

测试结果：
在这里插入图片描述

三、原子引用

3.1 AtomicReference

使用AtomicReference实现Account

public class AtomicReferenceTest {
    public static void main(String[] args) {
        Acount acount = new AccountBigDecimalSafe(new BigDecimal("10000"));
        Acount.demo(acount);
    }
}

class AccountBigDecimalSafe implements Acount {
    private AtomicReference<BigDecimal> balance;

    AccountBigDecimalSafe(BigDecimal balance) {
        this.balance = new AtomicReference<>(balance);
    }

    @Override
    public void withdraw(int amount) {
        while (true) {
            BigDecimal prev = balance.get();
            BigDecimal next = prev.subtract(new BigDecimal(amount));
            if (balance.compareAndSet(prev, next)) {
                break;
            }
        }
    }

    @Override
    public Integer getBalance() {
        return balance.get().intValue();
    }
}

3.2 ABA问题

字符串A，先改成了B又改回A，主线程发现字符串还是A，就改成了C。一般ABA问题不会有什么影响，但在实际工作中还是注意。

public class AbaTest {
    public static void main(String[] args) {
        AtomicReference atomicReference = new AtomicReference("A");
        System.out.println(atomicReference);
        new Thread(() -> {
            if (atomicReference.compareAndSet("A", "B")) {
                System.out.println(atomicReference);
            }
            if (atomicReference.compareAndSet("B", "A")) {
                System.out.println(atomicReference);
            }
        }).start();

        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        if (atomicReference.compareAndSet("A", "C")) {
            System.out.println(atomicReference);
        }
    }
}

3.3 AtomicMarkableReference

可以使用AtomicMarkableReference解决ABA问题

public class AbaTest2 {
    public static void main(String[] args) {
        AtomicMarkableReference<String> atomicReference = new AtomicMarkableReference("A",false);
        System.out.println(atomicReference.getReference());
        new Thread(() -> {
            if (atomicReference.compareAndSet("A", "B",false,true)) {
                System.out.println(atomicReference.getReference());
            }
            if (atomicReference.compareAndSet("B", "A",false,true)) {
                System.out.println(atomicReference.getReference());
            }
        }).start();

        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        if (atomicReference.compareAndSet("A", "C",false,true)) {
            System.out.println(atomicReference.getReference());
        }
    }
}

AtomicMarkableReference增加了是否改动过的标记，只要改动过，并被标记上，后面的改动就无法生效。

四、原子累加器

原子累加器，指的是累加操作是原子的，java8之前只能使用原子整数类的incrementAndGet方法，java8新增了LongAdder（并发大神狗哥，Doug Lea编写），专门用于累加操作，效率提升5倍。

public class LongAddrTest {

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            addr(() -> new AtomicLong(0), (AtomicLong::incrementAndGet));
        }
        for (int i = 0; i < 5; i++) {
            addr(LongAdder::new, LongAdder::increment);
        }

    }

    static <T> void addr(Supplier<T> supplier, Consumer<T> action) {
        T t = supplier.get();
        List<Thread> threads = new ArrayList<>(4);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 4; i++) {
            threads.add(new Thread(() -> {
                for (int j = 0; j < 500000; j++) {
                    action.accept(t);
                }
            }));
        }
        threads.forEach(Thread::start);
        threads.forEach(thread -> {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.currentTimeMillis();
        System.out.println("耗时：" + (end - start));

    }
}

测试结果：
在这里插入图片描述
LongAddr性能提升的原因是拆分了多个累加单元[cell0]…，当竞争激烈的时候，累加分散到多个cell减少失败重试，最后将结果汇总，最终减少竞争提高效率。

Integer_Double
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
乐观锁思想在 JAVA 中的实现——CAS
Q54665642ljf的博客
12-07 744
生活中我们看待一个事物总有不同的态度，比如半瓶水，悲观的人会觉得只有半瓶水了，而乐观的人则会认为还有半瓶水呢。很多技术思想往往源于生活，因此在多个线程并发访问数据的时候，有了悲观锁和乐观锁。悲观锁认为这个数据肯定会被其他线程给修改了，那我就给它上锁，只能自己访问，要等我访问完，其他人才能访问，我上锁、解锁都得花费我时间。乐观锁认为这个数据不会被修改，我就直接访问，当我发现数据真的修改了，那我也“礼貌的”让自己访问失败。悲观锁和乐观锁其实本质都是一种思想，在 JAVA 中对于悲观锁的实现大家可能都很了解，可以
Java锁策略——乐观锁（CAS）
xhhhx_的博客
04-19 1876
什么是CAS？ CAS：全程Compare and swap，“比较并交换”；一个CAS涉及3个操作： 我们假设内存中的原数据为V；自己的预期值为A，想要把原数据V修改成新值B。 比较A、V是否相等 若相等，将V修改成B 返回操作是否修改 CAS的伪代码： public boolean CAS(int V,int A,int B) { if(V==A){ V=B; return true; } return
Java并发编程总结——慎用CAS详解
09-02
下面小编就为大家带来一篇Java并发编程总结——慎用CAS详解。小编觉得挺不错的， 现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
乐观锁，CAS，ABA问题，synchronized锁升级过程
最新发布
kennyharris
02-11 961
乐观锁，CAS，ABA问题，synchronized锁升级过程
4、乐观锁和CAS
zhangshuai66的博客
08-25 496
Java乐观锁和CAS原理
java乐观锁 | CAS机制原理
devops
08-10 199
CAS（比较并交换）操作是一种原子性操作。原子性是指一个操作要么完全执行成功，要么完全不执行，没有中间状态。在CAS操作中，一个共享变量的比较和交换是作为一个原子操作来执行的，不会出现比较后、插入前，这段是时间有其他线程修改共享变量的值的情况。
Java进阶篇--乐观锁 & 悲观锁
m0_74293254的博客
10-15 397
2、悲观锁（Pessimistic Locking）： 悲观锁的思想是，假设并发的事务之间经常产生冲突，因此在操作数据时会先将其锁定，以防止其他事务对数据进行修改。乐观锁的优点是并发性能较高，不需要阻塞其他事务的执行，但是在并发冲突较多的情况下，需要频繁地回滚和重试，可能会影响性能。悲观锁的优点是保证数据的一致性，不会出现并发冲突的情况，但是会导致并发性能较低，因为其他事务需要等待锁的释放才能执行。乐观锁和悲观锁是在并发编程中用于处理数据一致性和并发控制的两种不同的策略。
乐观锁思想在JAVA中的实现——CAS
m0_71777195的博客
01-05 378
生活中我们看待一个事物总有不同的态度，比如半瓶水，悲观的人会觉得只有半瓶水了，而乐观的人则会认为还有半瓶水呢。很多技术思想往往源于生活，因此在多个线程并发访问数据的时候，有了悲观锁和乐观锁。悲观锁认为这个数据肯定会被其他线程给修改了，那我就给它上锁，只能自己访问，要等我访问完，其他人才能访问，我上锁、解锁都得花费我时间。乐观锁认为这个数据不会被修改，我就直接访问，当我发现数据真的修改了，那我也“礼貌的”让自己访问失败。
Java 中的各种锁和 CAS + 面试题
快乐的工程师的博客
02-08 3946
Java 中的各种锁和 CAS + 面试题 如果说快速理解多线程有什么捷径的话，那本文介绍的各种锁无疑是其中之一，它不但为我们开发多线程程序提供理论支持，还是面试中经常被问到的核心面试题之一。因此下面就让我们一起深入地学习一下这些锁吧。 乐观锁和悲观锁 悲观锁和乐观锁并不是某个具体的“锁”而是一种并发编程的基本概念。乐观锁和悲观锁最早出现在数据库的设计当中，后来逐渐被 Java 的并发包所引入。 ...
Java多线程 ---- CAS（乐观锁）的学习
咸鱼老潘的编码生活
09-26 172
Java多线程 ---- CAS（乐观锁）的学习
Java并发编程学习笔记
04-11
7、并发工具类CountDownLatch 、CyclicBarrier和Semaphore底层实现原理 8、线程池原理和如何使用线程池 9、ThreadLocal 为什么会内存泄漏 10、Volatile底层实现原理 11、AQS源码分析 12、CAS原理分析和使用场景 13、...
JAVA并发编程学习笔记之CAS操作
01-21
CAS操作 　CAS是单词compare and set的缩写，意思是指...采用锁可以解决此类问题，但CAS也可以解决，而且可以不加锁。   int expect = a; if(a.compareAndSet(expect，a+1)) { doSomeThing1();
java并发编程——内存模型
02-24
并发——在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行，但任一个时刻点上只有一个程序在处理机上运行——源自百度百科在并发编程中，我们需要...
【java并发编程】cas乐观锁
sumengnan的博客
05-30 790
一、cas是什么？ cas全程Compare and swap，比较并交换。一种无锁原子算法，是一种乐观锁，用于原子性的更新变量。 二、cas实现原理 CAS靠硬件实现,是一条CPU的原子指令,基于汇编指令cmpxchg(Intel x86)实现,其作用是让CPU先比较两个值是否相等,然后原子性地更新某个内存地址的值。 三、cas操作在java使用 unsafe类中的compareAndSwapInt方法 是经典实现 进入native方法，在c++源码unsafe.cpp文件中
【Java并发编程】锁机制——synchronized及乐观锁CAS
love and share
06-05 689
详细介绍了sychronized及乐观锁CAS的原理和使用
Java中的21种锁
新技术革命
09-03 689
本篇主要内容如下： 本篇主要内容 本篇文章已收纳到我的Java在线文档、 Github 我的SpringCloud实战项目持续更新中 帮你总结好的锁： 序号锁名称应用1乐观锁CAS2悲观锁synchronized、vector、hashtable3自旋锁CAS4可重入锁synchronized、Reentrantlock、Lock5读写锁ReentrantReadWriteLock，CopyOnWriteArrayList、CopyOnWriteArraySet6公平锁Reentrant.
【并发编程】（十二）Java乐观锁的实现——CAS
积木成林，聚沙成塔
03-04 849
文章目录1.CAS的概念2.为什么要有CAS3.CAS的缺点4.CAS的原理5.CAS在Java中的应用6.总结 1.CAS的概念 CAS的英文全称为CompareAndSwap，比较并替换的意思，通过这个名字可以大概猜到它的原理，在修改一个变量的时候需要用某种条件来做一个比较，如果比较成功则替换成新传入的值，如果比较失败就不执行更新操作。 CAS的设计思想是认为不会出现线程竞争，直接获取共享变量的值做修改，不需要在操作共享变量之前做阻塞的操作，整个行为表现的非常乐观，所有也被称为乐观锁。 2.为什么要有C
java并发编程学习笔记
08-30
学习Java中的并发编程模型以及相关的API，如Thread、Runnable、Lock、Condition等。 2. 线程安全性：学习如何保证多线程环境下的数据安全性，了解共享资源的问题以及如何使用同步机制来防止数据竞争和并发问题。 3...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值