专栏首页Java识堂CAS实现原理

CAS实现原理

前言

JUC是java.util.concurrent包的简称,JUC有2大核心,CAS和AQS,CAS是java.util.concurrent.atomic包的基础

@NotThreadSafe
public class CountTest {

    public static int count = 0;

    public static void main(String[] args) {

        //新建一个线程池
        ExecutorService service = Executors.newCachedThreadPool();
        //Java8 lambda表达式执行runnable接口
        for (int i = 0; i < 5; i++) {
            service.execute(() -> {
                for (int j = 0; j < 1000; j++) {
                    count++;
                }
            });
        }
        //关闭线程池
        service.shutdown();
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("count = " + count);
    }
}

由于这个代码是线程不安全的,所以最终结果有可能小于500,我们可以用synchronized保证操作的原子性和可见性

@ThreadSafe
public class CountTest {

    public static int count = 0;

    public static void main(String[] args) {

        ExecutorService service = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            service.execute(() -> {
                for (int j = 0; j < 1000; j++) {
                    synchronized (CountTest.class) {
                        count++;
                    }
                }
            });
        }
        service.shutdown();
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("count = " + count);
    }
}

synchronized属于悲观锁,它有一个明显的缺点,它不管数据存不存在竞争都加锁,随着并发量增加,且如果锁的时间比较长,其性能开销将会变得很大。有没有办法解决这个问题?答案是基于冲突检测的乐观锁。这种模式下,已经没有所谓的锁概念了,每个线程都直接先去执行操作,检测是否与其他线程存在共享数据竞争,如果没有则让此操作成功,如果存在共享数据竞争则不断地重新执行操作,直到成功为止,重新尝试的过程叫自旋

java.util.concurrent.atomic包就用到了CAS,如AtomicInteger可以用于Integer类型的原子性操作,可将上述代码改为如下,也是线程安全的

@ThreadSafe
public class CountTest {

    public static AtomicInteger count = new AtomicInteger(0);

    public static void main(String[] args) {

        ExecutorService service = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            service.execute(() -> {
                for (int j = 0; j < 1000; j++) {
                    synchronized (CountTest.class) {
                        //等价于count++,只不过是原子性的
                        count.getAndIncrement();
                    }
                }
            });
        }
        service.shutdown();
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("count = " + count);
    }
}

CAS介绍

CAS(Compare and Swap), 翻译成比较并交换。CAS有3个操作数,内存值V,旧的预期值A,要修改的新值B。当且仅当预期值A和内存值V相同时,将内存值V修改为B,否则什么都不做。

AtomicInteger源码分析

private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;

static {
    try {
        valueOffset = unsafe.objectFieldOffset
            (AtomicInteger.class.getDeclaredField("value"));
    } catch (Exception ex) { throw new Error(ex); }
}

private volatile int value;

AtomicInteger的值保存在value中,通过volatile保证操作的可见性,通过一个静态代码块来保证,类被加载时valueOffset已经有值了

Unsafe是一个不安全的类,提供了一些对底层的操作,我们是不能使用这个类的,valueOffset 是AtomicInteger对象value成员变量在内存中的偏移量

我们看getAndIncrement这个方法(和value++一个效果),能保证AtomicInteger类加1操作的原子性

public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
}
//第一个参数为当前这个对象,如count.getAndIncrement(),则这个参数则为count这个对象
//第二个参数为AtomicInteger对象value成员变量在内存中的偏移量
//第三个参数为要增加的值
public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        //调用底层方法得到value值
        var5 = this.getIntVolatile(var1, var2);
        //通过var1和var2得到底层值,var5为当前值,如果底层值=当前值,则将值设为var5+var4,并返回true,否则返回false
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

    return var5;
}

compareAndSwapInt是native方法,就不再分析

总结

并发比较低的时候用CAS比较合适,并发比较高用synchronized比较合适

CAS的缺点

1.只能保证对一个变量的原子性操作

2.长时间自旋会给CPU带来压力

3.ABA问题

本文分享自微信公众号 - Java识堂(erlieStar),作者:李立敏

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2018-04-17

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Mybatis框架和插件将动态代理玩出了新境界

    又是一年毕业季,很多小伙伴开始去大城市打拼。来大城市第一件事就是租房,免不了和中介打交道,因为很多房东很忙,你根本找不到他。从这个场景中就可以抽象出来代理模式

    Java识堂
  • Spring Boot是如何通过自动装配来简化开发的?

    最近用了一些spring-boot-starter-data的组件(redis,mongodb,jpa,elasticsearch等),才意识到Spring B...

    Java识堂
  • BAT都在使用的开源接口管理平台

    github上有本地安装的教程,因为docker安装比较方便,因此官方推荐了如下docker安装教程,当然docker镜像不是官方做的。建议配置阿里云Docke...

    Java识堂
  • LeetCode|560. 和为K的子数组--C++题解

    本题原本按我最喜欢的暴力破解提交的,结果到最后几个大数据的时候提示超时了,最后也是看了官方的思路,了解了动态规划的思路去解的这个题,所以本篇写了两个实现的方法。...

    Vaccae
  • 【LeetCode】旋转数组

    韩旭051
  • Leetcode 27. Remove Element

    Tyan
  • 编辑器之神 --- Vim

    版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。

    村雨遥
  • 关小刷刷题02——Leetcode 169. Majority Element 方法2和3

    题目 169. Majority Element Given an array of size n, find the majority element. Th...

    WZEARW
  • 【HDU - 5845】Best Division(xor-trie、01字典树、dp)

    饶文津
  • CAS && AtomicInteger

    大学里的混子

扫码关注云+社区

领取腾讯云代金券