专栏首页yukong的小专栏【java并发编程实战2】无锁编程CAS与atomic包1、无锁编程CAS2、 atomic族类

【java并发编程实战2】无锁编程CAS与atomic包1、无锁编程CAS2、 atomic族类

1、无锁编程CAS

1.1、CAS

CAS的全称是Compare And Swap 即比较交换,其算法核心思想如下

执行函数:CAS(V,E,N)

其包含3个参数

  • V表示要更新的变量
  • E表示预期值
  • N表示新值

如果V值等于E值,则将V的值设为N。若V值和E值不同,则说明已经有其他线程做了更新,则当前线程什么都不做。通俗的理解就是CAS操作需要我们提供一个期望值,当期望值与当前线程的变量值相同时,说明还没线程修改该值,当前线程可以进行修改,也就是执行CAS操作,但如果期望值与当前线程不符,则说明该值已被其他线程修改,此时不执行更新操作,但可以选择重新读取该变量再尝试再次修改该变量,也可以放弃操作,原理图如下

1535524330707.png

由于CAS操作属于乐观派,它总认为自己可以成功完成操作,当多个线程同时使用CAS操作一个变量时,只有一个会胜出,并成功更新,其余均会失败,但失败的线程并不会被挂起,仅是被告知失败,并且允许再次尝试,当然也允许失败的线程放弃操作,这点从图中也可以看出来。基于这样的原理,CAS操作即使没有锁,同样知道其他线程对共享资源操作影响,并执行相应的处理措施。同时从这点也可以看出,由于无锁操作中没有锁的存在,因此不可能出现死锁的情况,也就是说无锁操作天生免疫死锁。

1.2、CPU指令对CAS的支持

或许我们可能会有这样的疑问,假设存在多个线程执行CAS操作并且CAS的步骤很多,有没有可能在判断V和E相同后,正要赋值时,切换了线程,更改了值。造成了数据不一致呢?答案是否定的,因为CAS是一种系统原语,原语属于操作系统用语范畴,是由若干条指令组成的,用于完成某个功能的一个过程,并且原语的执行必须是连续的,在执行过程中不允许被中断,也就是说CAS是一条CPU的原子指令,不会造成所谓的数据不一致问题。

2、 atomic族类

在atomic包下共有AtomicBoolean、AtomicInteger、AtomicIntegerArray、AtmoicReference、AtomicReferenceFieldUpdater、LongAdder等类。

在上面线程不安全的例子中,我们用1000个线程调用整型变量的i的自增,然后输出i最后的大小,在多线程情况下,这明显是线程不安全的,因为i++不是原子操作,这里我们可以使用AtomicInteger代替Integer。

public class AtomicIntegerExample {

    /**
     * 并发线程数目
     */
    private static int threadNum = 1000;

    /**
     * 闭锁
     */
    private static CountDownLatch countDownLatch  = new CountDownLatch(threadNum);

    private static AtomicInteger i = new AtomicInteger(0);
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int j = 0; j < threadNum; j++) {
            executorService.execute(() -> {
                add();
            });
        }
        // 使用闭锁保证当所有统计线程完成后,主线程输出统计结果。 其实这里也可以使用Thread.sleep() 让主线程阻塞等待一会儿实现
        countDownLatch.await();
        System.out.println(i.get());
    }

    private static void add() {
        countDownLatch.countDown();
        i.getAndIncrement();
    }

}

上面的代码就是线程安全的,运行输出 i=1000,这是为什么呢。我们来看看getAndIncrement()方法的实现

    /**
     * Atomically increments by one the current value.
     *
     * @return the previous value
     */
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

我们看到方法是由一个unsafe对象的getAndAddInt方法实现。我们继续点进去看看getAndAddInt方法的实现。

    public final int getAndAddInt(Object var1, long var2, int var4) {
        //
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
     }

上面就是getAndAddInt方法的实现,具体流程如下,

1、首先根据当前的传过来的对象指针,获取期望的值 var5,

2、然后while判断调用compareAndSwapInt方法 ,这是一个native本地方法,它有四个参数,

第一个参数,当前的对象,第二个参数实际的值,第三个参数期望的值,第四个参数想要更新的值。

只有实际的值等于期望的值的时候,才会把值更新成第四个参数,也就是想要的更新的值,否则一直循环尝试。

这也就是无锁编程,CAS。

在高并发的场景,这种循环尝试的次数会比较高,成功率会比较低,这样性能会比较差。但是在JDK8中推出了一个新的类名为LongAdder

我们看看它的用法。我们也继续上面的求和的例子,只需要把AtomicInteger改成LongAddr然后更改对应调用的方法即可。具体代码如下。

public class LongAdderExample {

    /**
     * 并发线程数目
     */
    private static int threadNum = 1000;

    /**
     * 闭锁
     */
    private static CountDownLatch countDownLatch  = new CountDownLatch(threadNum);

    private static LongAdder i = new LongAdder();
    
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int j = 0; j < threadNum; j++) {
            executorService.execute(() -> {
                add();
            });
        }
        // 使用闭锁保证当所有统计线程完成后,主线程输出统计结果。 其实这里也可以使用Thread.sleep() 让主线程阻塞等待一会儿实现
        countDownLatch.await();
        System.out.println(i);
    }

    private static void add() {
        countDownLatch.countDown();
        i.increment();
    }

}

运行程序,发现结果与预期的一样i=1000,是线程安全的。那么我们看看它又是如何。保证线程安全的呢。

由于篇幅原因我不跟入源码讲解了,大致思想与ConcurrentHashMapy大致一致,采用的是热点分离法,

把value分成base+cells数组,避免所有的写操作都是在value上面,这样就保证提高性能,但是在多线程情况下,统计会有误差。

接着我们讲解CAS中常常会遇到的ABA问题。

比如说一个线程one从内存位置V中取出A,这时候另一个线程two也从内存中取出A,并且two进行了一些操作变成了B,然后two又将V位置的数据变成A,这时候线程one进行CAS操作发现内存中仍然是A,然后one操作成功。尽管线程one的CAS操作成功,但是不代表这个过程就是没有问题的。如果链表的头在变化了两次后恢复了原值,但是不代表链表就没有变化。

这里我们可以借助乐观锁的一个概念,使用version版本号来判断是否一致,每次操作后版本号加1如果两次对比版本号一致才交换,这样就避免了ABA问题,在atomic包下面也提供了对应的类AtomicStampedReference

AtomicStampedReference每次操作前判断更新的时间戳与预期的时间戳是否一致,这样就巧妙的避免了ABA问题。

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

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Java多线程编程-(16)-无锁CAS操作以及Java中Atomic并发包的“18罗汉”

    通过上面的学习,我们应该很清楚的知道了在多线程并发情况下如何保证数据的安全性和一致性的两种主要方法:一种是加锁,另一种是使用ThreadLocal。锁是一种以时...

    Java后端技术
  • 【原创】Java并发编程系列12 | 揭秘CAS

    并发编程,为了保证数据的安全,需要满足三个特性:原子性、可见性、有序性。Java 中可以通过锁和 CAS 的方式来实现原子操作。

    java进阶架构师
  • 并发编程-03线程安全性之原子性(Atomic包)及原理分析

    并发编程-06线程安全性之可见性 (synchronized + volatile)

    小小工匠
  • 并发编程之Atomic&Unsafe魔法类详解

    并发编程之Atomic&Unsafe魔法类详解–原子(atom)本意是“不能被进一步分割的最小粒子”,而原子操作(atomic operation)意为”不可被...

    一滴水的眼泪
  • 上篇 | 说说无锁(Lock-Free)编程那些事

    ? 1. 引言 现代计算机,即使很小的智能机亦或者平板电脑,都是一个多核(多CPU)处理设备,如何充分利用多核CPU资源,以达到单机性能的极大化成为我们码农进...

    腾讯技术工程官方号
  • 并发编程之Atomic&Unsafe魔法类详解

    原子(atom)本意是“不能被进一步分割的最小粒子”,而原子操作(atomic operation)意为”不可被中断的一个或一系列操作”。在多处理器上实现原子操...

    一滴水的眼泪
  • Synchronized 源码分析

    前面我们已经介绍和分析了管程,而 Synchronized 则是 JVM 层面中管程的一种实现,它通过对细节的屏蔽方便了开发人员的使用。

    itliusir
  • 不用synchronized块的话如何实现一个原子的i++?

    上周被问到这个问题,没想出来,后来提示说concurrent包里的原子类。回来学习一下。 一、何谓Atomic?  Atomic一词跟原子有点关系,后者曾被人认...

    老白
  • Java CAS 原理分析

    CAS 全称是 compare and swap,是一种用于在多线程环境下实现同步功能的机制。CAS 操作包含三个操作数 -- 内存位置、预期数值和新值。CAS...

    田小波
  • 探究CAS原理(基于JAVA8源码分析)define LOCK_IF_MP(mp) "cmp $0, " #mp "; je 1f; lock; 1: "define LOCK_IF_MP(mp) _

    JavaEdge
  • 深入浅出CAS

    CAS(Compare and Swap),即比较并替换,实现并发算法时常用到的一种技术,Doug lea大神在java同步器中大量使用了CAS技术,鬼斧神工的...

    java爱好者
  • 浅谈 Java 并发下的乐观锁

    我们知道,原子(atom)指化学反应不可再分的基本微粒。在 Java 多线程编程中,所谓原子操作,就是即使命令涉及多个操作,这些操作依次执行,不会被别的线程插队...

    程序IT圈
  • Java Concurrent CAS使用&原理

    CAS 可以简单描述比较并交换,Java中轻量级锁的理论支持。CAS很早就出现了,并且以此为理论基础实现了很多有趣的工具,Java依赖的就是操作系统中的cmpx...

    邹志全
  • 乐观锁(CAS)

    多线程在提高我们程序的并发度的同时,也引入线程的安全问题,即多个线程对共享变量的操作是非线程安全的,为了解决线程安全问题,我们引入了锁。锁大体分为两类:

    shysh95
  • 面试必问的CAS,你懂了吗?

    CAS(Compare-and-Swap),即比较并替换,是一种实现并发算法时常用到的技术,Java并发包中的很多类都使用了CAS技术。CAS也是现在面试经常问...

    Java架构师必看
  • Java 的 CAS原理

    在计算机科学中,比较和交换(Conmpare And Swap)是用于实现多线程同步的原子指令。它将内存位置的内容与给定值进行比较,只有在相同的情况下,将该内存...

    用户3467126
  • 垃圾回收机制与无锁化编程(Garbage Collection and Lock-Free Programming)

    垃圾回收机制(GC)对大部分开发者来说应该不陌生,特别是Java开发者或多或少都跟GC打过交道。 GC的优点是实现对堆上分配的内存动态回收,避免内存泄漏。但是G...

    王璞
  • 理解Java轻量级并发包Atom系列工具类的设计

    他们的主要功能是提供轻量级的同步能力从而帮助我们避免内存一致性错误,从源码中观察这些工具类其设计主要利用了CAS原语+volatile的功能。我们知道volat...

    我是攻城师
  • JUC 中的 Atomic 原子类

    Java1.5的Atomic包名为java.util.concurrent.atomic。

    Vincent-yuan

扫码关注云+社区

领取腾讯云代金券