Java并发之CAS原理详解

目录
  • 开端
  • 1.代码
    • 1.1修改后的代码
    • 1.2代码改进:CAS模仿
  • 2.CAS分析
    • 2.1Java对CAS的支持
    • 2.2CAS实现原理是什么?
    • 2.3CAS存在的问题
      • 2.3.1什么是ABA问题?
      • 2.3.2如何解决ABA问题
  • 总结

开端

在学习源码之前我们先从一个需求开始

需求

我们开发一个网站,需要对访问量进行统计,用户每发送一次请求,访问量+1.如何实现?我们模拟有100个人同时访问,并且每个人对咱们的网站发起10次请求,最后总访问次数应该是1000次

1.代码

package day03;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
/**
 * Description
 * User:
 * Date:
 * Time:
 */
public class Demo {
    //总访问量
    static int count = 0;
    //模拟访问的方法
    public static void request() throws InterruptedException {
        //模拟耗时5毫秒
        TimeUnit.MILLISECONDS.sleep(5);
        count++;
    }
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();
        int threadSize=100;
        CountDownLatch countDownLatch = new CountDownLatch(threadSize);
        for (int i=0;i<threadSize;i++){
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    //每个用户访问10次网站
                    try {
                        for (int j=0;j<10;j++) {
                            request();
                        }
                    }catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        countDownLatch.countDown();
                    }
                }
            });
            thread.start();
        }
        //怎么保证100个线程执行之后,执行后面的代码
        countDownLatch.await();
        long endTime = System.currentTimeMillis();
        System.out.println(Thread.currentThread().getName()+"耗时:"+(endTime-startTime)+",count:"+count);
    }
}

我们多输出几次结果

main耗时:66,count:950

main耗时:67,count:928

发现每一次count都不相同,和我们期待的1000相差一点,这里就牵扯到了并发问题,我们的count++在底层实际上由3步操作组成

  • 获取count,各个线程写入自己的工作内存
  • count执行+1操作
  • 将+1后的值写回主存中

这并不是一个线程安全的过程,如果有A、B两个线程同时执行count++,同时执行到第一步,得到的count是一样的,三步操作完成后,count只加1,导致count结果不正确

那么怎么解决这个问题呢?

我们可以考虑使用synchronized关键字和ReentrantLock对资源加锁,保证并发的正确性,多线程的情况下,可以保证被锁住的资源被串行访问

1.1修改后的代码

package day03;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
/**
 * Description
 * User:
 * Date:
 * Time:
 */
public class Demo02 {
    //总访问量
    static int count = 0;
    //模拟访问的方法
    public static synchronized void request() throws InterruptedException {
        //模拟耗时5毫秒
        TimeUnit.MILLISECONDS.sleep(5);
        count++;
    }
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();
        int threadSize=100;
        CountDownLatch countDownLatch = new CountDownLatch(threadSize);
        for (int i=0;i<threadSize;i++){
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    //每个用户访问10次网站
                    try {
                        for (int j=0;j<10;j++) {
                            request();
                        }
                    }catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        countDownLatch.countDown();
                    }
                }
            });
            thread.start();
        }
        //怎么保证100个线程执行之后,执行后面的代码
        countDownLatch.await();
        long endTime = System.currentTimeMillis();
        System.out.println(Thread.currentThread().getName()+"耗时:"+(endTime-startTime)+",count:"+count);
    }
}

执行结果

main耗时:5630,count:1000

可以看到,由于sychronized锁住了整个方法,虽然结果正确,但因为线程执行方法均为串行执行,导致运行效率大大下降

那么我们如何才能使程序执行无误时,效率还不会降低呢?

缩小锁的范围,升级上述3步中第三步的实现

  • 获取锁
  • 获取count最新的值,记作LV
  • 判断LV是否等于A,如果相等,则将B的值赋值给count,并返回true,否则返回false
  • 释放锁

1.2代码改进:CAS模仿

package day03;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
/**
 * Description
 * User:
 * Date:
 * Time:
 */
public class Demo03 {
    //总访问量
    volatile static int count = 0;
    //模拟访问的方法
    public static void request() throws InterruptedException {
        //模拟耗时5毫秒
        TimeUnit.MILLISECONDS.sleep(5);
//        count++;
        int expectCount;
        while (!compareAndSwap(expectCount=getCount(),expectCount+1)){}
    }
    /**
     * @param expectCount 期待的值,比如最刚开始count=3
     * @param newCount 新值 count+1之后的值,4
     * @return
     */
    public static synchronized  boolean compareAndSwap(int expectCount,int newCount){
        if (getCount()==expectCount){
            count = newCount;
            return true;
        }
        return false;
    }
    public static int getCount(){return count;}
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();
        int threadSize=100;
        CountDownLatch countDownLatch = new CountDownLatch(threadSize);
        for (int i=0;i<threadSize;i++){
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    //每个用户访问10次网站
                    try {
                        for (int j=0;j<10;j++) {
                            request();
                        }
                    }catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        countDownLatch.countDown();
                    }
                }
            });
            thread.start();
        }
        //怎么保证100个线程执行之后,执行后面的代码
        countDownLatch.await();
        long endTime = System.currentTimeMillis();
        System.out.println(Thread.currentThread().getName()+"耗时:"+(endTime-startTime)+",count:"+count);
    }
}

main耗时:67,count:1000

2.CAS分析

CAS全称“CompareAndSwap”,中文翻译过来为“比较并替换”

定义:

  • CAS操作包含三个操作数——内存位置(V)期望值(A)新值(B)。如果内存位置的值和期望值匹配,那么处理器会自动将该位置值更新为新值。否则处理器不作任何操作。无论哪种情况,它都会在CAS指令之前返回该位置的值。
  • CAS在一些特殊情况下仅返回CAS是否成功,而不提取当前值,CAS有效的说明了我认为位置V应该包含值A,如果包含该值,将B放到这个位置,否则不要更改该位置的值,只告诉我这个位置现在的值即可

2.1Java对CAS的支持

java中提供了对CAS操作的支持,具体在sun.misc.unsafe类中,声明如下

public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
  • 参数var1:表示要操作的对象
  • 参数var2:表示要操作属性地址的偏移量
  • 参数var4:表示需要修改数据的期望的值
  • 参数var5:表示需要修改的新值

2.2CAS实现原理是什么?

CAS通过调用JNI的代码实现,JNI:java native interface,允许java调用其他语言。而compareAndSwapxxx系列的方法就是借助C语言来调用cpu底层指令实现的

以常用的Intel x86平台为例,最终映射到cpu的指令为"cmpxchg",这是一个原子指令,cpu执行此命令时,实现比较并替换的操作

现代计算机动不动就上百核心,cmpxchg怎么保证多核心下的线程安全?

系统底层在进行CAS操作的时候,会判断当前系统是否为多核心系统,如果是就给“总线”加锁,只有一个线程会对总线加锁成功,加锁之后执行CAS操作,也就是说CAS的原子性是平台级别的

2.3CAS存在的问题

2.3.1什么是ABA问题?

CAS需要在操作值的时候检查下值有没有发生变化,如果没有发生变化则更新,但是如果一个值原来是A,在CAS方法执行之前,被其他线程修改为B,然后又修改回了A,那么CAS方法执行检查的时候会发现它的值没有发生变化,但是实际却不是原来的A了,这就是CAS的ABA问题

可以看到上图中线程A在真正更改A之前,A已经被其他线程修改为B然后又修改为A了

程序模拟ABA问题

package day04;
import java.util.concurrent.atomic.AtomicInteger;
/**
 * Description
 * User:
 * Date:
 * Time:
 */
public class Test01 {
    public static AtomicInteger a = new AtomicInteger();
    public static void main(String[] args) {
        Thread main = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行,a的值为:"+a.get());
                try {
                    int expect = a.get();
                    int update = expect+1;
                    //让出cpu
                    Thread.sleep(1000);
                    boolean b = a.compareAndSet(expect, update);
                    System.out.println(Thread.currentThread().getName()+"CAS执行:"+b+",a的值为:"+a.get());
                }
                 catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"主线程");
//        main.start();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(20);
                    a.incrementAndGet();
                    System.out.println(Thread.currentThread().getName()+"更改a的值为:"+a.get());
                    a.decrementAndGet();
                    System.out.println(Thread.currentThread().getName()+"更改a的值为:"+a.get());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"其他线程");
        main.start();
        thread1.start();
    }
}

主线程执行,a的值为:0
其他线程更改a的值为:1
其他线程更改a的值为:0
主线程CAS执行:true,a的值为:1

可以看到,在执行CAS之前,a被其他线程修改为1又修改为0,但是对执行CAS并没有影响,因为它根本没有察觉到其他线程对a的修改

2.3.2如何解决ABA问题

解决ABA问题最简单的方案就是给值加一个修改版本号,每次值变化,都会修改它的版本号,CAS操作时都去对比此版本号

在java中的ABA解决方案(AtomicStampedReference

AtomicStampedReference主要包含一个对象引用及一个可以自动更新的整数stamp的pair对象来解决ABA问题

AtomicStampedReference源码

    /**
     * Atomically sets the value of both the reference and stamp
     * to the given update values if the
     * current reference is {@code ==} to the expected reference
     * and the current stamp is equal to the expected stamp.
     *
     * @param expectedReference the expected value of the reference 期待引用
     * @param newReference the new value for the reference          新值引用
     * @param expectedStamp the expected value of the stamp         期望引用的版本号
     * @param newStamp the new value for the stamp                  新值的版本号
     * @return {@code true} if successful
     */
    public boolean compareAndSet(V   expectedReference,
                                 V   newReference,
                                 int expectedStamp,
                                 int newStamp) {
        Pair<V> current = pair;
        return
            expectedReference == current.reference &&//期望引用与当前引用保持一致
            expectedStamp == current.stamp &&//期望引用版本号与当前版本号保持一致
            ((newReference == current.reference &&//新值引用与当前引用一致并且新值版本号与当前版本号保持一致
              newStamp == current.stamp)
                    ||//如果上述版本号不一致,则通过casPair方法新建一个Pair对象,更新值和版本号,进行再次比较
             casPair(current, Pair.of(newReference, newStamp)));
    }
    private boolean casPair(Pair<V> cmp, Pair<V> val) {
        return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
    }

使用AtomicStampedReference解决ABA问题代码

package day04;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;
/**
 * Description
 * User:
 * Date:
 * Time:
 */
public class Test02 {
    public static AtomicStampedReference<Integer> a = new AtomicStampedReference(new Integer(1),1);
    public static void main(String[] args) {
        Thread main = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行,a的值为:"+a.getReference());
                try {
                    Integer expectReference = a.getReference();
                    Integer newReference = expectReference+1;
                    Integer expectStamp = a.getStamp();
                    Integer newStamp = expectStamp+1;
                    //让出cpu
                    Thread.sleep(1000);
                    boolean b = a.compareAndSet(expectReference, newReference,expectStamp,newStamp);
                    System.out.println(Thread.currentThread().getName()+"CAS执行:"+b);
                }
                catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"主线程");
//        main.start();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(20);
                    a.compareAndSet(a.getReference(),a.getReference()+1,a.getStamp(),a.getStamp()+1);
                    System.out.println(Thread.currentThread().getName()+"更改a的值为:"+a.getReference());
                    a.compareAndSet(a.getReference(),a.getReference()-1,a.getStamp(),a.getStamp()-1);
                    System.out.println(Thread.currentThread().getName()+"更改a的值为:"+a.getReference());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"其他线程");
        main.start();
        thread1.start();
    }
}

主线程执行,a的值为:1
其他线程更改a的值为:2
其他线程更改a的值为:1
主线程CAS执行:false

因为AtomicStampedReference执行CAS会去检查版本号,版本号不一致则不会进行CAS,所以ABA问题成功解决

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注我们的更多内容!

(0)

相关推荐

  • Java多线程CAS操作原理代码实例解析

    CAS操作号称无锁优化,也叫作自旋:对于一些常见的操作需要加锁,然后jdk就提供了一些以Atomic开头的类,这些类内部自动带了锁,当然这里的锁并非是用synchronized来实现的,而是通过CAS操作来实现的: 一.下面是 AtomicInteger 的使用: package com.designmodal.design.juc01; import java.util.ArrayList; import java.util.List; import java.util.concurrent.

  • Java CAS基本实现原理代码实例解析

    一.前言 了解CAS,首先要清楚JUC,那么什么是JUC呢?JUC就是java.util.concurrent包的简称.它有核心就是CAS与AQS.CAS是java.util.concurrent.atomic包的基础,如AtomicInteger.AtomicBoolean.AtomicLong等等类都是基于CAS. 什么是CAS呢?全称Compare And Swap,比较并交换.CAS有三个操作数,内存值V,旧的预期值E,要修改的新值N.当且仅当预期值E和内存值V相同时,将内存值V修改为N

  • Java switch case数据类型原理解析

    这篇文章主要介绍了Java switch case数据类型原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 Java 中 switch case 语句用来判断一个变量与一系列值中某个值是否相等,每个值称为一个分支. 语法格式如下: switch(expression){ case value : //语句 break; //可选 case value : //语句 break; //可选 //你可以有任意数量的case语句 default

  • Java原子操作CAS原理解析

    一.CAS(Compare And Set) Compare And Set(或Compare And Swap),CAS是解决多线程并行情况下使用锁造成性能损耗的一种机制,CAS操作包含三个操作数--内存位置(V).预期原值(A).新值(B).如果内存位置的值与预期原值相匹配,那么处理器会自动将该位置值更新为新值.否则,处理器不做任何操作.无论哪种情况,它都会在CAS指令之前返回该位置的值.CAS有效地说明了"我认为位置V应该包含值A:如果包含该值,则将B放到这个位置:否则,不要更改该位置,只

  • Java CAS底层实现原理实例详解

    这篇文章主要介绍了Java CAS底层实现原理实例详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 一.CAS(compareAndSwap)的概念 CAS,全称Compare And Swap(比较与交换),解决多线程并行情况下使用锁造成性能损耗的一种机制. CAS(V, A, B),V为内存地址.A为预期原值,B为新值.如果内存地址的值与预期原值相匹配,那么将该位置值更新为新值.否则,说明已经被其他线程更新,处理器不做任何操作:无论哪种情

  • 简单了解JavaCAS的相关知识原理

    JMM与问题引入 为啥先说JMM,因为CAS的实现类中维护的变量都被volatile修饰, 这个volatile 是遵循JMM规范(不是百分百遵循,下文会说)实现的保证多线程并发访问某个变量实现线程安全的手段 一连串的知识点慢慢缕 首先说什么是JMM, JMM就是大家所说的java的内存模型, 它是人们在逻辑上做出的划分, 或者可以将JMM当成是一种规范, 有哪些规范呢? 如下 可见性: 某一个线程对内存中的变量做出改动后,要求其他的线程在第一事件内马上马得到通知,在CAS的实现中, 可见性其实

  • Java并发之CAS原理详解

    目录 开端 1.代码 1.1修改后的代码 1.2代码改进:CAS模仿 2.CAS分析 2.1Java对CAS的支持 2.2CAS实现原理是什么? 2.3CAS存在的问题 2.3.1什么是ABA问题? 2.3.2如何解决ABA问题 总结 开端 在学习源码之前我们先从一个需求开始 需求 我们开发一个网站,需要对访问量进行统计,用户每发送一次请求,访问量+1.如何实现?我们模拟有100个人同时访问,并且每个人对咱们的网站发起10次请求,最后总访问次数应该是1000次 1.代码 package day0

  • Java并发之Condition案例详解

    目录 一.Condition接口介绍和示例 二.Condition接口常用方法 三.Condition接口原理简单解析 3.1.等待 3.2.通知 四.总结 五.利用Condition实现生产者消费者模式 在使用Lock之前,我们使用的最多的同步方式应该是synchronized关键字来实现同步方式了.配合Object的wait().notify()系列方法可以实现等待/通知模式.Condition接口也提供了类似Object的监视器方法,与Lock配合可以实现等待/通知模式,但是这两者在使用方

  • Java中synchronized实现原理详解

    记得刚刚开始学习Java的时候,一遇到多线程情况就是synchronized,相对于当时的我们来说synchronized是这么的神奇而又强大,那个时候我们赋予它一个名字"同步",也成为了我们解决多线程情况的百试不爽的良药.但是,随着我们学习的进行我们知道synchronized是一个重量级锁,相对于Lock,它会显得那么笨重,以至于我们认为它不是那么的高效而慢慢摒弃它. 诚然,随着Javs SE 1.6对synchronized进行的各种优化后,synchronized并不会显得那么

  • 入门到精通Java SSO单点登录原理详解

    目录 1. 基础概念 2. 单点登录 3. CAS 流程 4. OAuth 流程 5. CAS和OAuth的区别 1. 基础概念 SSO单点登录(Single sign-on) 所谓单点登录就是在多个应用系统中,用户只需登录一次就可以访问所有相互信任的系统. CAS 中央认证服务(Central Authentication Service) CAS是由美国耶鲁大学发起的一个企业级开源项目,旨在为WEB应用系统提供一种可靠的单点登录解决方案(WEB SSO). OAuth2.0 开放授权(Ope

  • 前端开发之CSS原理详解

    前端开发之CSS原理详解 从事Web前端开发的人都与CSS打交道很多,有的人也许不知道CSS是怎么去工作的,写出来的CSS浏览器是怎么样去解析的呢?当这个成为我们提高CSS水平的一个瓶颈时,是否应该多了解一下呢? 一.浏览器的发展与CSS 网页浏览器主要通过 HTTP 协议连接网页服务器而取得网页, HTTP 容许网页浏览器送交资料到网页服务器并且获取网页.目前最常用的 HTTP 是 HTTP/1.1,这个协议在 RFC2616 中被完整定义.HTTP/1.1 有其一套 Internet Exp

  • Java并发之不可思议的死循环详解

    下面的代码将发生死循环: package com.zzj.concurrency; public class VolatileObjectTest implements Runnable{ private ObjectA objectA; // 加上volatile 就可以正常结束While循环了 public VolatileObjectTest(ObjectA a) { this.objectA = a; } public ObjectA getA() { return objectA; }

  • Java静态static关键字原理详解

    这篇文章主要介绍了Java静态static关键字原理详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 static关键字既可以修饰成员变量,也可以修改成员方法,修饰的成员变量和成员方法可以直接通过类名调用,也可以通过对象调用(其实即使是通过对象调用,也会被翻译成类名调用),建议通过类名调用. 成员方法用static修饰后,就成为了静态方法,静态方法不属于对象,而是属于类. 注意事项: 1.静态方法中不能使用this,因为this指的是当前对象

  • Java多线程 线程状态原理详解

    这篇文章主要介绍了Java多线程 线程状态原理详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 java.lang.Thread.State枚举定义了6种线程状态. NEW: 尚未启动(start)的线程的线程状态 RUNNABLE: 运行状态,但线程可能正在JVM中执行,也可能在等待CPU调度 BLOCKED: 线程阻塞,等待监视器锁以进入同步代码块/方法 WAITING: 等待状态.使用以下不带超时的方式时会进入:Object.wait.

  • Java接口和抽象类原理详解

    这篇文章主要介绍了Java接口和抽象类原理详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 对于面向对象编程来说,抽象是它的一大特征之一.在Java中,可以通过两种形式来体现OOP的抽象:接口和抽象类.这两者有太多相似的地方,又有太多不同的地方.很多人在初学的时候会以为它们可以随意互换使用,但是实际则不然.今天我们就一起来学习一下Java中的接口和抽象类.下面是本文的目录大纲: 一.抽象类 在了解抽象类之前,先来了解一下抽象方法.抽象方法是一

  • Java钩子方法概念原理详解

    这篇文章主要介绍了Java钩子方法概念原理详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 钩子方法源于设计模式中模板方法(Template Method)模式,模板方法模式的概念为:在一个方法中定义一个算法的骨架,而将一些步骤延迟到子类中.模板方法使得子类可以在不改变算法结构的情况下,重新定义算法中的某些步骤.其主要分为两大类:模版方法和基本方法,而基本方法又分为:抽象方法(Abstract Method),具体方法(Concrete Me

随机推荐