并发编程——CAS原理

1 引入

package com.src.fdf;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

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(100);
        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 );


    }}

i++操作实际上由三部分构成（具体见jvm执行引擎）

具体步骤：①、获取i的值，放在操作数栈里，记作A，即A=i；

　　　　　②、将A的值+1，得到B，即B=A+1；

　　　　　③、将B的值赋值给内存中的i；

如果有A. B两个线程同时执行count++，他们通知执行到上面步骤的第一步，得到的count是一样的， 3步操作结束后，count只加1，导致count结果不正确!

Q:怎么解决结果不正确问题?

★A:对count++操作的时候，我们让多个线程排队处理，多个线程同时到达request()方法的时候，只能允许一个线程可以进去操作，其它的线程在外面等着，等里面的处理完毕出来之后，外面等着的再进去一个，这样操作的count++就是排队进行的，结果一定是正确的。

Q:怎么实现排队效果? ?

A: java中synchronized 关键字和ReentrantLock都可以实现对资源枷锁，保证并发正确性，多线程的情况下可以保证被锁住的资源被“串行”访问。

package com.src.fdf;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class Demo02 {
    //总访问量
    static int count = 0;
    //模拟访问的方法

    public synchronized 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(100);
        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 );


    }}

得出结果但是耗时太长

Q:耗时太长的原因是什么呢?

A:程序中的request方法使用synchronized关键字修饰，保证了并发情况下，request 方法同时刻只允许一个线程进入， request加锁相当于串行执行了，count的结果和我们预期的-致，知识耗时太长了. .

Q:如何解决耗时长的问题?

A:count ++操作实际上是由3步来完成! (jvm执行引擎)

1. 获取count的值，记做A : A=count
2.将A值+1,得到B : B=A+1
3.将B值赋值给count
升级第3步的实现:
　　1.获取锁
　　2.获取以下count最新的值，记做LV
　　3.判断LV是否等于A，如果相等，则将B的值赋值给count, 并返回true, 否则返回false
　　4.释放锁

最终代码：里面的compareAndSwap方法就是模拟的CAS，比较并交换

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * ClassName: Demo
 * Description:
 * date: 2020/2/22 20:24
 *
 * @author 暴躁小刘讲师，微信：vv517956494
 * 想要购买本套JDK 1.8 ConcurrentHashMap 源码讲解课程的同学，可以加我微信！
 * 我摊牌了，我就是来卖课的...（家里的孩子还等着我赚钱买奶粉呢...）
 * <p>
 * 小刘讲师决定站着把钱挣了，如果购买后感觉课程不硬核并且指出问题所在，
 * 小刘讲师立刻返还所有课程费用，一分钱不收！
 * @since 1.0.0
 */
public class Demo03 {
    //总访问量
    volatile static int count = 0;
    //模拟访问的方法
    public static void request() throws InterruptedException {
        //模拟耗时5毫秒
        TimeUnit.MILLISECONDS.sleep(5);

        int expectCount; //表示期望值
        while(!compareAndSwap((expectCount = getCount()), expectCount + 1)) {}
    }

    /**
     * @param expectCount 期望值count
     * @param newCount 需要给count赋值的新值
     * @return 成功返回 true 失败返回false
     */
    public static synchronized boolean compareAndSwap(int expectCount, int newCount) {
        //判断count当前值是否和期望值expectCount一致，如果一致 将newCount赋值给count
        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);
    }
}

2 java里面的CAS

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

2.1 定义

CAS操作包含三个操作数一内存位置 (V) 、期望值(A)和新值(B)如果内存位置的值与期望值匹配，那么处理器会自动将该位置值更新为新值。否则，处理器不作任何操作。无论哪种情况，它都会在CAS指令之前返回该位置的值。

(CAS在一些特殊情况下仅返回CAS是否成功，而不提取当前值) CAS有效的说明了“我认为位置V应该包含值A;如果包含该值，则将B放到这个位置;否则，不要更改该位置的值，只告诉我这个位置现在的值即可。”

2.2 怎么使用JDK提供的CAS支持?

A: java中提供了对CAS操作的支持，具体在sun.misc .unsafe类中，声明如下:
public final native boolean compar eAndSwap0bject(0bject var1, long var2， object var4, object var5) ;
public f inal native boolean compar eAndSwapIht(object var1, long var2， int var4, int var5) ;
public f inal native boolean compar eAAdSwapl ong (Object var1, long var 2，long var4，long var6) ;

参数var1:表示要操作的对象
参数var2:表示要操作对象中属性地址的偏移量（对象下面的属性的地址相对于对象本身的地址的偏移量）
参数var4:表示需要修改数据的期望的值
参数var5:表示需要修改为的新值

2.3 CAS实现原理

CAS通过调用JNI的代码实现，JNI：java Native Interface，允许java调用其它语言。而compareAndSwapxxx系列的方法就是借助“C语言”来调用cpu底层指令实现的。
以常用的Intel x86平台来说，最终映射到的cpu的指令为“cmpxchg”，这是一个原子指令，cpu执行此命令时，实现比较并替换的操作！

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

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

ABA问题

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

public class CasABADemo {
    public static AtomicInteger a = new AtomicInteger(1);

    public static void main(String[] args) {
        Thread main = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("操作线程" + Thread.currentThread().getName() + ", 初始值：" + a.get());
                try {

                    int expectNum = a.get();
                    int newNum = expectNum + 1;
                    Thread.sleep(1000);//主线程休眠一秒钟，让出cpu

                    boolean isCASSccuess = a.compareAndSet(expectNum, newNum);
                    System.out.println("操作线程" + Thread.currentThread().getName() + "，CAS操作：" + isCASSccuess);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "主线程");

        Thread other = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(20);//确保Thread-main线程优先执行

                    a.incrementAndGet();//a + 1,a=2
                    System.out.println("操作线程" + Thread.currentThread().getName() + "，【increment】,值=" +a.get());
                    a.decrementAndGet();//a - 1,a=1
                    System.out.println("操作线程" + Thread.currentThread().getName() + "，【decrement】,值=" +a.get());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "干扰线程");

        main.start();
        other.start();
    }
}

如何解决ABA问题？

解决ABA最简单的方案就是给值加一个修改版本号，每次值变化，都会修改它的版本号，CAS操作时都去对比此版本号。 ——原子引用（带版本号的原子操作）

AtomicStampedReference类就提供了这样的方案

public class CasABADemo02 {
    public static AtomicStampedReference<Integer> a = new AtomicStampedReference(new Integer(1), 1);

    public static void main(String[] args) {
        Thread main = new Thread(() -> {
                System.out.println("操作线程" + Thread.currentThread().getName() + ", 初始值：" + a.getReference());
                try {

                    Integer expectReference = a.getReference();
                    Integer newReference = expectReference + 1;
                    Integer expectStamp = a.getStamp();
                    Integer newStamp = expectStamp + 1;

                    Thread.sleep(1000);//主线程休眠一秒钟，让出cpu

                    boolean isCASSccuess = a.compareAndSet(expectReference, newReference, expectStamp, newStamp);
                    System.out.println("操作线程" + Thread.currentThread().getName() + "，CAS操作：" + isCASSccuess);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
        }, "主线程");

        Thread other = new Thread(() -> {
                try {
                    Thread.sleep(20);//确保Thread-main线程优先执行

                    a.compareAndSet(a.getReference(), (a.getReference() + 1), a.getStamp(), (a.getStamp() + 1));
                    System.out.println("操作线程" + Thread.currentThread().getName() + "，【increment】,值=" +a.getReference());
                    a.compareAndSet(a.getReference(), (a.getReference() - 1), a.getStamp(), (a.getStamp() + 1));
                    System.out.println("操作线程" + Thread.currentThread().getName() + "，【decrement】,值=" +a.getReference());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

        }, "干扰线程");

        main.start();
        other.start();
    }
}

posted @ 2020-10-14 22:08 Mistolte 阅读(294) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Mistolte