标签：void this 基于 field valueof 时间 调用 是什么 exception
CAS就是compareAndSwap的缩写即我们所说的比较交换。cas是一种基于锁的操作。而且是乐观锁。
先看一个代码
import java.util.concurrent.atomic.AtomicInteger;
public class CASDemo {
public static void main(String[] args) {
checkCAS();
}
private static void checkCAS() {
AtomicInteger atomicInteger = new AtomicInteger(5);
System.out.println(atomicInteger.compareAndSet(5, 2019) + "\t current data is " + atomicInteger.get());
System.out.println(atomicInteger.compareAndSet(5, 2014) + "\t current data is " + atomicInteger.get());
}
}结果
true current data is 2019
false current data is 2019再看图
大致理解：主物理内存是5，t1和t2线程从主物理内存获取5之后，在自己的线程工作内存去操作，t1把自己工作内存中的5改成2019,在同步到主物理内存的时候，会先看此时主物理内存的值是不是5，如果是5，就改成2019，当然，之前t2线程，也把5取到自己的工作内存，改成2018，但是现在，t1已经把主物理内存的值修改了，此时t2，同步回主物理内存的时候，发现主物理内存的值已经不是5了，而是2019，所以会false，不能发生交换。这就是所谓的比较和交换。比较是真实值和期望值的比较。值相同就可以交换，不同不能交换。
或者说为什么用CAS不用synchronized呢？
/**
* Atomically increments by one the current value.
*
* @return the previous value
*/
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}那么什么是Unsafe 类呢？
public class AtomicInteger extends Number implements java.io.Serializable {
private static final long serialVersionUID = 6214790243416807050L;
// setup to use Unsafe.compareAndSwapInt for updates
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;
static {
try {
// 获取下面 value 的地址偏移量
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
private volatile int value;
// ...
}那么继续看看getAndAddInt()方法
// unsafe.getAndAddInt
public final int getAndAddInt(Object obj, long valueOffset, long expected, int val) {
int temp;
do {
temp = this.getIntVolatile(obj, valueOffset); // 获取快照值
} while (!this.compareAndSwap(obj, valueOffset, temp, temp + val)); // 如果此时 temp 没有被修改，就能退出循环，否则重新获取
return temp;
}如图
CAS有三个操作数，内存值V，旧的预测值A，要修改的更新值B。
当且仅当预期值A和内存值v相同时，将内存值V修改为B，否则什么都不做，自己自旋锁。
1、循环时间长，开销时间大
如果CAS失败，那么就会一直尝试，如果CAS一直不成功，会一直执行do while，死循环，可能会给CPU带来很大的开销。2、只能保证一个共享变量的原子性。
对于多个共享变量的操作，循环CAS就无法保证操作的原子性，这个时候就可以用锁来保证原子性。3、引出 ABA 问题
**这是CAS最大的缺点**，那么ABA问题的描述是什么呢？如下图那么ABA问题怎么产生的呢？
如上图，
继续ABA问题
对于一个普通的原子引用
package threadDemo.casDemo;
import java.util.concurrent.atomic.AtomicReference;
class User{
String name ;
int age;
public User(String name,int age){
this.age = age;
this.name = name;
}
}
public class AtomicReferenceDemo {
public static void main(String[] args) {
User cuzz = new User("cuzz", 18);
User faker = new User("faker", 20);
AtomicReference<User> atomicReference = new AtomicReference<>();
atomicReference.set(cuzz);
System.out.println(atomicReference.compareAndSet(cuzz, faker)); // true
System.out.println(atomicReference.get()); // User(userName=faker, age=20)
}
}对于ABA问题的解决，先通过一个程序看看ABA的产生
import java.util.concurrent.atomic.AtomicReference;
public class ABADemo {
private static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);
public static void main(String[] args) {
new Thread(() -> {
atomicReference.compareAndSet(100, 101);
atomicReference.compareAndSet(101, 100);
}).start();
new Thread(() -> {
// 保证上面线程先执行
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
atomicReference.compareAndSet(100, 2019);
System.out.println(atomicReference.get()); // 2019
}).start();
}
}当有一个值从 A（100） 改为 B（101） 又改为 A（100），这就是 ABA 问题。
ABA问题的结局
加版本号，和值一样，有一个期望版本号和实际版本号，具体实现如下
时间戳原子引用
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;
public class ABADemo2 {
private static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100, 1);
public static void main(String[] args) {
new Thread(() -> {
int stamp = atomicStampedReference.getStamp();
System.out.println(Thread.currentThread().getName() + " 的版本号为：" + stamp);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
atomicStampedReference.compareAndSet(100, 101, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1 );
atomicStampedReference.compareAndSet(101, 100, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1 );
}).start();
new Thread(() -> {
int stamp = atomicStampedReference.getStamp();
System.out.println(Thread.currentThread().getName() + " 的版本号为：" + stamp);
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
boolean b = atomicStampedReference.compareAndSet(100, 2019, stamp, stamp + 1);
System.out.println(b); // false
System.out.println(atomicStampedReference.getReference()); // 100
}).start();
}
}先保证两个线程的初始版本为一致，后面修改是由于版本不一样就会修改失败。这样就可以避免ABA问题。
标签：void this 基于 field valueof 时间 调用 是什么 exception
原文地址：https://www.cnblogs.com/zhangxinying/p/12444185.html
