其他分享
首页 > 其他分享> > CAS概念和解析

CAS概念和解析

作者:互联网

一、CAS概念  

package syncbasics;

import java.util.concurrent.CountDownLatch;

/**
 * 多线程访问同一份数据,会产生竞争,race condition => 竞争条件
 * 就有可能产生数据的不一致,并发访问之下产生的不期望出现的结果
 * 如何保障数据的一致呢?---->线程同步(线程执行的顺序安排好),
 * 具体:保障操作的原子性(Atomicity)
 * 1.悲观的认为这个操作会被别的线程打断(悲观锁)synchronized
 * 2.乐观的认为这个操作不会被别的线程打断(乐观锁)cas操作
 * CAS = Compare And Set/Swap/Exchange
 *
 * ++操作:
 * 把n从内存里面读到寄存器里,加完了之后,再写回去。
 * 还没来得及写回去的时候,另外的线程读到了原值,
 * 因此,++这个正在执行的操作被另外线程打断了。
 *
 * 只要我们能保证这个执行的操作不被打断,即保证我这个线程读过来之后改完这个值1,再写回去之后,其他线程才能执行,
 * 那最后的结果一定是对的。这种不能够被打断的操作称之为原子操作。
 *
 * 什么样的语句是原子性的?什么样的不是?
 * java内存中的8大原子操作,了解即可。要查汇编手册。
 *
 * synchronized:
 * 让原来的并发变成了序列化。
 * synchronized本身是保证可见性的,n++结束了之后这个线程一定是要和主内存做同步,主内存里一定都是最新的。
 * synchronized保障了可见性、原子性。
 * 那么保证有序性吗?
 * ----不可以,synchronized里面的代码块里面的操作指令完全有可能换顺序。DCL要加volatile就是证明了。
 *
 * CAS概念:
 * 还以下面这个小程序n++操作来说明CAS的概念。
 * n开始等于0,线程1把n读过来加1,原来是需要加锁的,现在整个过程不上锁了,把0读过来改成1之后,再往回写
 * 的过程之中做个判断,判断原值依然是否为0,如果依然为0,说明在线程1读0加1的过程中,没有人来过,那就直接把1
 * 写回去,搞定。
 * 万一中间有人改了呢?万一其他线程已经将0改成8了,线程1把1往回写的时候发现原值已经变为8了,不是你所期望的0,
 * 这时候怎么办?那就再来一遍,把8读出来加1变成9,把9往回写的过程之中看看判断原值是否依然为8,如依然为8,说明在我
 * 将8改为9的过程之中没有其他人来过,那就直接将9写回去了,搞定。
 * 当然,如果将8读来加1的过程之中又有人打断了,有人将8改成100了,怎么办?那就把100读过来加1,将101往回写的过程中判断
 * 原值是否依然是100....一直到某一次成功了为止。
 * 你会发现它就在这里不停的循环,读取当前值,计算结果,比较当前值和新值,如果当前值和新值相等,更新为新值。如果不相等,
 * 就再来一遍,总有一次能成功。
 *
 * CAS的ABA问题:
 * 上面的这段话描述里面有个很重要的问题,此0非彼0的问题,线程1把0读过来改成了1,往回写的过程中发现原值依然为0,但是
 * 这个0是不是你所看到的那个0呢?未必,有可能在这个过程之中,这个0被别的线程改成了8,又被别的线程改回了0!中间有个
 * 0->8->0的过程,此0非彼0,A->B->A,这就是ABA问题。
 * 但是咱们这个程序是不存在这个问题,只是理论上有,简单数据类型就算ABA问题,但是对我而言没关系,这种可以不在乎,略过。
 * 但是在有些情况下,是要解决的。如果这个值是一个引用的话,读过来引用值,对它的属性进行了一些修改,它是一个对象,当你再
 * 往回写的时候,有可能这个引用指向的对象里面的内容发生了改变,引用依然还是这个引用,但是里面的内容发生了改变,这时就要
 * 在乎这个ABA问题了。
 *
 * 解决ABA问题:
 * 加version,你的女朋友,你早上离开了她,晚上回来发现依然是她,但此她还是彼她嘛?你比较怀疑,怎么办?在她脑门上写1.0,你就
 * 走了,回来的时候依然是她,不过如果中间经过任何其他线程操作,这个ver1.0都会加1。这时候你发现她脑门上是99.0,那肯定中间经过
 * 了改变,当然就看你在乎不在乎。所以加version,加版本就可以解决。
 *
 * CAS的底层原子性保障:
 * 除了ABA问题,CAS还有一个巨大问题。分析一下:
 * 线程1将0读过来改成1,把1往回写的过程中是一个CAS操作。CAS叫compare and swap,compare and set,伪代码就是:
 * if(v==0){v=1},这个操作实际上底层就是两步:比较和设定。那万一当你执行完if(v==0)后,这个时间点上被另外线程打断,
 * 另外线程把0改成8了,那线程1又将8->1,那还是出问题了,数据还是不一致!
 * 所以,如果想让CAS产生作用的话,必须保证CAS操作本身必须是原子性的。
 *
 */
public class T00_IPlusPlus {
    private static long n = 0L;

    public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[100];
        CountDownLatch latch = new CountDownLatch(threads.length);

        for(int i=0; i<threads.length; i++){
            threads[i] = new Thread(() -> {
               for(int j=0; j<10000; j++){
                   synchronized (T00_IPlusPlus.class) {
                       n++;
                   }
               }
               latch.countDown();
            });
        }

        for(Thread t : threads){
            t.start();
        }

        latch.await();

        System.out.println(n);
    }
}

 

二、AtomicXXX类:

package atomicxxx;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 这里就是一种CAS机制
 * incrementAndGet每次往回写的时候都要比较一下,看下是否原值是我期望的那个值。
 * incrementAndGet操作自带原子性:
 * unsafe.getAndAddInt->this.compareAndSwapInt->native boolean compareAndSwapInt
 * 得益于CPU在汇编级别上支持指令:cmpxchg,但是cmpxchg不是原子性的,最终实现:
 * lock cmpxchg
 * 所以你会发现,CAS在宏观上我们叫做自旋锁,乐观锁,但它在底层上的实现,微观上的实现实际上是一个悲观锁。
 */
public class T01_AtomicInteger {

    AtomicInteger count = new AtomicInteger(0);

    void m(){
        for(int i=0; i<10000; i++){
            count.incrementAndGet();
        }
    }

    public static void main(String[] args) {
        T01_AtomicInteger t = new T01_AtomicInteger();

        List<Thread> threads = new ArrayList<>();

        for(int i=0; i<100; i++){
            threads.add(new Thread(t::m, "thread-" + i));
        }

        threads.forEach(o -> o.start());
        threads.forEach(o -> {
            try {
                o.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println(t.count);
    }
}

 

 

 

 

 

 

---

标签:ABA,原值,读过来,CAS,概念,线程,操作,解析
来源: https://www.cnblogs.com/tenWood/p/16026043.html