5.4 CAS
CAS（Compare And Swap），是由硬件实现的。
CAS可以将read-modify-write这类的操作转换为原子操作。
i++包括三个操作：读取i的值、i+1、将新的值保存到内存。
CAS的原理：在把值写到内存中时，会再次读取该地址的值，如果发现主存中的值与一开始读取到的值不同，则放弃写入（即撤销本次操作）；否则就更新进去。
使用CAS实现一个线程安全的计数器：
package cas;
public class CASTest {
public static void main(String[] args) {
CASCounter casCounter = new CASCounter();
for(int i = 0; i < 1000; i++) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + ": " + casCounter.increment());
}
}, "Thread" + i).start();
}
}
}
class CASCounter{
private long value;
private boolean compareAndSwap(long expectedValue, long oldValue, long newValue) {
if(expectedValue == oldValue) {
value = newValue;
return true;
} else return false;
}
public long increment() {
long oldValue = value;
long newValue;
do {
newValue = value + 1;
} while (compareAndSwap(value, oldValue, newValue));
return value;
}
}
CAS的ABA问题：
CAS实现原子性的背后有一个假设：如果共享变量的当前值与期望值相同，就假设共享变量没有被更改过。
但事实可能不是如此：x初始值位0，A将x修改为10，B将x又修改为0，此刻能否认为x没有被更改过呢？这就是CAS的ABA问题。
如果实际业务需要避免ABA问题，那么我们可以引入一个变量表示版本号，或者称修订号。每进行一次修改，修订号增加1。如果遇到当前版本号与期望版本号不一致，则获取新的版本号并继续修改。此时的过程是这样的。[A, 0] -> [B, 1] -> [C, 2]
5.5 原子变量类
原子变量类是基于CAS实现的。当我们对共享变量进行reda-modify-write的更新操作时，通过原子变量类可以保障操作的原子性和可见性。
read-modify-write操作指的是：对于此次操作，变量的新值依赖于变量的旧值。而不是像那种赋值操作。
前面提到过，volatile只能保障可见性，不能保障原子性。而原子变量类的内部使用的是volatile修饰的变量，并且使用CAS保障了原子性。有时将原子变量类看成是增强的volatile变量。
| 分组 | 原子变量类 |
| 基础数据型 | AtomicInteger、AtomicLong、AtomicBoolean |
| 数组 | AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray |
| 字段更新器 | AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdater |
| 引用型 | AtomicReference、AtomicStampedReference、AtomicMarkableReference |
AtomicLong：
package atomics.atomicLong;
import java.util.concurrent.atomic.AtomicLong;
//我们想要让整个计算过程只使用这一个计算器，所以这里我们将其设计成单例
public class Indicator {
//将构造方法私有化
private Indicator(){}
//创建一个静态的实例类
private static Indicator instance = new Indicator();
//返回上面的那个实例类
public static Indicator getInstance() {
return instance;
}
//记录请求数
private AtomicLong requestNum = new AtomicLong(0);
//记录成功数
private AtomicLong successNum = new AtomicLong(0);
//记录失败数
private AtomicLong failureNum = new AtomicLong(0);
//请求数增加
public void requestProcess() {
requestNum.incrementAndGet();
}
//成功数增加
public void requestProcessSuccess() {
successNum.incrementAndGet();
}
//失败数增加
public void requestProcessFailure() {
failureNum.incrementAndGet();
}
//获取请求数
public Long getRequestNum() {
return requestNum.get();
}
//获取成功数
public Long getRequestSuccessNum() {
return successNum.get();
}
//获取失败数
public Long getRequestFailureNum() {
return failureNum.get();
}
}
atomicArray：
package atomics.atomicIntegerArray;
import java.util.concurrent.atomic.AtomicIntegerArray;
public class Test {
public static void main(String[] args) {
//1、创建一个具有指定长度的原子数组
AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(10);
System.out.println(atomicIntegerArray);
//2、返回指定位置的元素
System.out.println(atomicIntegerArray.get(0));
System.out.println(atomicIntegerArray.get(1));
//3、设置指定位置元素的值
atomicIntegerArray.set(0, 1);
System.out.println(atomicIntegerArray.getAndSet(0, 2)); //先获取旧值，再获取新值
//4、修改某个数组元素的值
System.out.println(atomicIntegerArray.addAndGet(0, 5)); //先修改，再返回
System.out.println(atomicIntegerArray.getAndAdd(0, 6)); //先返回，再修改
//5、CAS操作
atomicIntegerArray.compareAndSet(0, 13, 222); //如果0位置的值是22，就修改为222
System.out.println(atomicIntegerArray.get(0));
//6、自增/自减
System.out.println(atomicIntegerArray.incrementAndGet(0)); //先增再获得
System.out.println(atomicIntegerArray.getAndIncrement(0)); //先获得再增
System.out.println(atomicIntegerArray.decrementAndGet(0)); //先减再获得
System.out.println(atomicIntegerArray.getAndDecrement(0)); //先获得再减
}
}
AtomicIntegerFieldUpdater：字段更新器
AtomicIntegerFieldUpdater可以对原子整数字段进行更新，要求：
- 字段必须使用volatile修饰，是其在线程间可见。
- 只能是实例变量，不能是静态变量，也不能用final修饰
package atomics.atomicIntegerField;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
public class SubThread extends Thread{
//要更新的user对象
private User user;
//创建更新器，对user对象的age字段进行更新
private AtomicIntegerFieldUpdater<User> updater = AtomicIntegerFieldUpdater.newUpdater(User.class, "age");
public SubThread(User user) {
this.user = user;
}
@Override
public void run() {
//在子线程中对user对象的age自增10次
for(int i = 0; i < 10; i++) {
updater.incrementAndGet(user);
}
}
}
AtomicReference：原子引用对象
package atomics.atomicReference;
import java.util.concurrent.atomic.AtomicReference;
public class Test01 {
//创建一个reference对象
static AtomicReference<String> atomicReference = new AtomicReference<>("abc");
public static void main(String[] args) {
for(int i = 0; i < 100; i++) {
int temp = i;
new Thread(new Runnable() {
@Override
public void run() {
atomicReference.set(atomicReference.get() + temp);
System.out.println(atomicReference.get());
}
}).start();
}
}
}
AtomicStampedReference：解决CAS中的ABA问题
package atomics.atomicStampedReference;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;
/**
* AtomicStampedReference原子类可以用来解决CAS中的ABA问题
* AtomicStampedReference原子类中有一个整数标记值stamp，每次执行CAS操作时，会比较它的版本。
*/
public class Test01 {
private static AtomicStampedReference<String> atomicStampedReference = new AtomicStampedReference<>("abc", 0);
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
atomicStampedReference.compareAndSet("abc", "def", atomicStampedReference.getStamp(),
atomicStampedReference.getStamp()+1);
System.out.println(Thread.currentThread().getName() + ": " + atomicStampedReference.getReference());
atomicStampedReference.compareAndSet("def", "abc", atomicStampedReference.getStamp(),
atomicStampedReference.getStamp()+1);
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
int stamp = atomicStampedReference.getStamp();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(atomicStampedReference.compareAndSet("abc", "ggg", stamp,
atomicStampedReference.getStamp()+1));
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(atomicStampedReference.getReference());
}
}