原子操作CAS
CAS的原理
CAS(Compare And Swap),指令级别保证这是一个原子操作
三个运算符: 一个内存地址V,一个期望的值A,一个新值B
基本思路:如果地址V上的值和期望的值A相等,就给地址V赋给新值B,如果不是,不做任何操作。
synchronized和CAS(悲观锁和乐观锁是抽象的)
- synchronized是悲观锁,这种线程一旦得到锁,其他需要锁的线程就挂起的情况就是悲观锁。
- CAS操作的就是乐观锁,每次不加锁而是假设没有冲突而去完成某项操作,如果因为冲突失败就重试,直到成功为止。
sychronized
首先Synchronized是确保线程安全的,但是在性能上却不是最优的。Synchronized关键字会让没有得到锁资源的线程进入BLOCKED状态,而后在争夺到锁资源后恢复为RUNNABLE状态,这个过程中涉及到操作系统用户模式和内核模式的转换,代价比较高。 尽管Java1.6为Synchronized做了优化,增加了从偏向锁到轻量级锁再到重量级锁的过度,但是在最终转变为重量级锁之后,性能仍然较低。
原子性操作类
jdk提供了java.util.concurrent.atomic包,并且这些类都是使用Unsafe实现的包装类。
1.原子更新基本类型
atomic提供了3个类用于原子更新基本类型:分别是AtomicInteger原子更新整形,AtomicLong原子更新长整形,AtomicBoolean原子更新bool值。都是大同小异,所以AtomicInteger为例说明。
AtomicInteger常用方法:(这里我找到一个大概的规律,一般get在前,add、set、Increment等等在后,就是先返回,再处理;反之add、set、Increment等等再前的,就是先处理,再返回)
1.int addAndGet(int delta):以原子的方式将输入的值与实例中的值相加,并把结果返回
2.boolean compareAndSet(int expect, int update):如果输入值等于预期值,以原子的方式将该值设置为输入的值
3.final int getAndIncrement():以原子的方式将当前值加1,并返回加1之前的值
4.void lazySet(int newValue):最终会设置成newValue,使用lazySet设置值后,可能导致其他线程在之后的一小段时间内还是可以读到旧的值。
5.int getAndSet(int newValue):以原子的方式将当前值设置为newValue,并返回设置之前的旧值
public class UseAtomicInt {
static AtomicInteger ai = new AtomicInteger(10);
public static void main(String[] args) {
System.out.println(ai.getAndIncrement());//10--->out--->11 先返回再增加
System.out.println(ai.incrementAndGet());//11--->12--->out 先增加再返回
System.out.println(ai.addAndGet(1));//12+1--->13--->out 先增加再返回
System.out.println(ai.incrementAndGet());//13--->14--->out 先增加再返回
System.out.println(ai.getAndSet(20));//14--->out--->20 先返回再相加
System.out.println(ai.get());
}
}
10
12
13
14
14
20
2.原子更新数组
atomic里提供了三个类用于原子更新数组里面的元素,分别是:AtomicIntegerArray:原子更新整形数组里的元素,AtomicLongArray:原子更新长整形数组里的元素,AtomicReferenceArray:原子更新引用数组里的元素
AtomicIntegerArray主要提供了以原子方式更新数组里的整数,常见方法如下:
int addAndGet(int i, int delta):以原子的方式将输入值与数组中索引为i的元素相加
boolean compareAndSet(int i, int expect, int update):如果当前值等于预期值,则以原子方式将数组位置i的元素设置成update值。
public class AtomicArray {
static int[] value = new int[] { 1, 2 };
static AtomicIntegerArray ai = new AtomicIntegerArray(value);
public static void main(String[] args) {
ai.getAndSet(0, 3);// 在0角标,添加数据为3
ai.addAndGet(0,2);// 在0角标的数据上加2
System.out.println(ai.get(0));// 5
System.out.println(value[0]); // 1
}
}
5
1
3.原子更新引用
原子引用类型atomic包主要提供了以下几个类:AtomicReference:原子更新引用类型,AtomicReferenceFieldUpdater:原子更新引用类型里的字段
AtomicReference为例:
public class UseAtomicReference {
static AtomicReference<UserInfo> userRef = new AtomicReference<UserInfo>();
public static void main(String[] args) {
UserInfo user = new UserInfo("Mark", 15);//要修改的实体的实例
userRef.set(user);
UserInfo updateUser = new UserInfo("Bill", 17);//要变化的新实例
userRef.compareAndSet(user, updateUser);// updateUser覆盖user
System.out.println(userRef.get().getName());
System.out.println(userRef.get().getAge());
System.out.println(user.getName());
System.out.println(user.getAge());
}
//定义一个实体类
static class UserInfo {
private String name;
private int age;
public UserInfo(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
}
Bill
17
Mark
15
4.原子更新属性
如果需要原子更新某个对象的某个字段,就需要使用原子更新属性的相关类,atomic中提供了一下几个类用于原子更新属性:
AtomicIntegerFieldUpdater:原子更新整形属性的更新器
AtomicLongFieldUpdater:原子更新长整形的更新器
AtomicStampedReference:原子更新带有版本号的引用类型。该类将整数值与引用关联起来,可用于原子的更新数据和数据的版本号,可以解决使用CAS进行原子更新时可能出现的ABA问题。
AtomicStampedReference为例:
public class UseAtomicStampedReference {
static AtomicStampedReference<String> asr =
new AtomicStampedReference<>("Mark",0);
public static void main(String[] args) throws InterruptedException {
final int oldStamp = asr.getStamp();//那初始的版本号
final String oldReferenc = asr.getReference();
System.out.println(oldReferenc+"==========="+oldStamp);
Thread rightStampThread = new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()
+"当前变量值:"+oldReferenc+"当前版本戳:"+oldStamp+"-"
+asr.compareAndSet(oldReferenc, oldReferenc+"Java",
oldStamp, oldStamp+1));
}
});
Thread errorStampThread = new Thread(new Runnable() {
@Override
public void run() {
String reference = asr.getReference();
System.out.println(Thread.currentThread().getName()
+"当前变量值:"+reference+"当前版本戳:"+asr.getStamp()+"-"
+asr.compareAndSet(reference, reference+"C",
oldStamp, oldStamp+1));
}
});
rightStampThread.start();
rightStampThread.join();
errorStampThread.start();
errorStampThread.join();
System.out.println(asr.getReference()+"==========="+asr.getStamp());
}
}
Mark===========0
Thread-0当前变量值:Mark当前版本戳:0-true
Thread-1当前变量值:MarkJava当前版本戳:1-false
MarkJava===========1
模拟AtomicInteger的类实现了线程安全的:get方法和compareAndSet()方法,自行实现它的递增方法
public class HalfAtomicInt {
private AtomicInteger atomicI = new AtomicInteger(0);
public void increament() {
for (;;) { // 自旋
int i = atomicI.get();
boolean suc = atomicI.compareAndSet(i, ++i);// 直到compare成功
if (suc) {
break;
}
}
}
public int getCount() {
return atomicI.get();
}
}
CAS的缺点:
1.CPU开销较大
在并发量比较高的情况下,如果许多线程反复尝试更新某一个变量,却又一直更新不成功,循环往复,会给CPU带来很大的压力。2.不能保证代码块的原子性
CAS机制所保证的只是一个变量的原子性操作,而不能保证整个代码块的原子性。比如需要保证3个变量共同进行原子性的更新,就不得不使用Synchronized了。
CAS的ABA问题:
当我们要对Value进行操作的时候,要先拿到Value这个值,然后在操作一遍,但是最终得到的全新的Value和原来的Value一样。这样就是我们的ABA,A经过B操作后得到的还是A。那么这就会导致CAS有一个漏洞。判断全新Value和原来的Value相等,也不能确定原来的Value没有被修改。
那么怎么解决呢?JDK中的AtomicStampedReference这个类给我们每个变量的状态值都配备了一个时间戳,也就是每个变量在比较值相等的同时,也会比较时间戳,这样就避免了ABA问题的产生。