CAS

CAS详解

1.CAS

cas通俗点说就是比较和交换,synchronized是一种悲观锁,那么cas就是乐观锁;

悲观锁:就是线程独占,只有当这个线程结束,才能有其它线程使用

乐观锁:乐观锁就是不加锁,假设没有冲突,而完成某项操作,如果冲突失败就重试

2.CAS的底层思想

实例:

public class CASdemo {
    public static void main(String[] args) {
     AtomicInteger atomicInteger=new AtomicInteger(0);
        for (int i = 0; i <20 ; i++) {
            new Thread(()->{
                for (int j = 0; j <100 ; j++) {
                    atomicInteger.getAndIncrement();
                }
            },String.valueOf(i)).start();
        }
​
        try{
            TimeUnit.SECONDS.sleep(3);//估计3秒上面的20个线程跑完
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println(atomicInteger.get());
    }
}

 

​

原子类AtomicInteger源码:

//成员变量Volatile保证了可见性,以及禁止指令重排
private volatile int value;
​
//++方法
  public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }
​
​

 

unSafe类

//var1为对象 var2就是value内存偏移量就是的内存地址,
 public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            //到var1这个对象,var2位置拿值
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));//这个方法,是先判断现在拿到的值,是不是还是那个值,如果是,就替换,返回true,自旋结束,否则false,重新拿值;这就是一种乐观锁
        return var5;
    }
​
//下面这两个方法都是本地方法,它们的底层都是C++实现的,是系统的原语,具有原子性
public native int getIntVolatile(Object var1, long var2);
 public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

 

 

4.CAS缺点

1.循环时间长开销时间大

有一个自旋,所以时间开销大

2.只能保证一个共享变量的原子操作

只能保证一个对象

3.ABA问题

例子:

AtomicInteger a=new AtomicInteger(0);
a=0;
​
//假如线程1运行时间是20,将a变为10
//线程2运行时间是5,将a变为5或0;
​
//当线程运行时
//线程1运行 此时拿到a=0
//线程2运行 将a变为5   时间过5
//线程2再次运行 将a变为0 时间过5
//时间过10 ,到线程1要写值时a=0余主内存a=0一致将 a=10写入
​
//此时a已经被改写过,只不过还是原来的值,但是线程1不知道,这就是aba的问题

 

如何规避这个ABA问题?

简单直接,加个时间戳

代码实例:

class User{
    String name;
    byte age;
}
public class ABAdemo {
    public static void main(String[] args) {
        User A=new User();
        A.name="A";
        A.age=18;
        User B=new User();
        B.name="B";
        B.age=20;
        //一个对象,1为版本号
 AtomicStampedReference<User> atomicStampedReference = new AtomicStampedReference<>(A,1);
        System.out.println("获得对象"+atomicStampedReference.getReference());
        
        //对象比对,版本号比对
        atomicStampedReference.compareAndSet(A,B,1,2);
        System.out.println("修改后"+atomicStampedReference.getReference());
    }
}