CSDN个人博客:https://blog.csdn.net/wangrain1
了解了Java虚拟机,线程,锁,volatile概念之后对多线程开发算是比较熟悉了。解决线程并发产生的问题,除了锁,volatile等关键字之外,在特定的情景下为了提高代码运行的效率,为了摆脱“锁”这个独占式的编程方式之外,还有另外一个原子类的概念。
在java.util.concurrent.atomic包下有Java提供的线程安全的原子类。了解 AtomicInteger 和 CAS 机制。
1. AtomicInteger的实现
通过上一篇中volatile的自增的例子,我们知道要想实现这种自赠的效果就需要加锁,为了提高效率,这种场景下原子类型就可以胜任。
AtomicIntegerai =new AtomicInteger(1);
ai.incrementAndGet();
查看实现代码:
/**
* Atomically increments by one the current value.
*
* @return the updated value
*/
public final int incrementAndGet() {
return U.getAndAddInt(this, VALUE, 1) + 1;
}
根据incrementAndGet()方法了解到AtomicInteger是对U的一个封装,U就是Unsafe类。
private static final sun.misc.Unsafe U = sun.misc.Unsafe.getUnsafe();
private static final long VALUE;
static {
try {
VALUE = U.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (ReflectiveOperationException e) {
throw new Error(e);
}
}
private volatile int value;
这段代码首先获得Unsafe对象,先声明一下Unsafe是个单例,Unsafe里面基本都是native方法。
static代码块里面初始化了VALUE这个值,static修饰的类加载的时候就会被初始化,并且引用是放到 Jvm的方法区的属于类的数据。
继续VALUE是什么呢?查看U.objectFieldOffset()方法:
/**
* Gets the raw byte offset from the start of an object's memory to
* the memory used to store the indicated instance field.
*
* @param field non-null; the field in question, which must be an
* instance field
* @return the offset to the field
*/
public long objectFieldOffset(Field field) {
return field.getOffset();
}
看方法注释:从对象的内存处开始,获得原始字节偏移量,用于存储实力对象的内存。好像还是不理解~。画个图:
上几篇提到对象在内存中的分布其中有个padding对齐,就是保证一个对象的内存大小必须是8的倍数。在这里偏移量的意思就像我们 new 一个数组,数组的地址就是数组地一个元素的地址,假如数组地址是 a,第二个元素就是a+1,其中+1就是偏移量。对应的对象的一个属性的偏移量就是其对象的地址开始增加,增加的数就是这个filed的偏移量。
对于VALUE这个值我们知道了,他是AtomicInteger中的value属性对应的偏移量,就是对象地址+VALUE = value的地址
继续看代码:
/**
* Atomically increments by one the current value.
*
* @return the updated value
*/
public final int incrementAndGet() {
return U.getAndAddInt(this, VALUE, 1) + 1;
}
/**
* Atomically adds the given value to the current value of a field
* or array element within the given object {@code o}
* at the given {@code offset}.
*
* @param o object/array to update the field/element in
* @param offset field/element offset
* @param delta the value to add
* @return the previous value
* @since 1.8
*/
// @HotSpotIntrinsicCandidate
public final int getAndAddInt(Object o, long offset, int delta) {
int v;
do {
v = getIntVolatile(o, offset);
} while (!compareAndSwapInt(o, offset, v, v + delta));
return v;
}
知道了offset值的意义之后
继续向下就是 v = getIntVolatile(o, offset); 这段代码,这个代码含义其实就是根据object和属性在object中的偏移地址,拿到 v(对应的共享内存中的 value 值,通过volatile控制值的可见性)。
compareAndSwapInt(o, offset, v, v + delta) 这个就是CAS(CompareAndSwap)机制 = 先拿着 v(预期的值)和 共享内存的值做比较 如果其他线程没有修改过就替换掉,否则就一直自旋判断直到成功。
如果在比较过程中不成功,也就是值被其他线程修改了,这时候CAS机制是一直循环的,这样无非也会消耗大量CPU。
2. CAS实现原子性操作的三大问题
这部分引用于:https://www.jianshu.com/p/5ee20d1128da
CAS虽然很高的解决了原子操作,但是CAS仍然存在三大问题。ABA问题、循环时间长开销大、以及只能保证一个共享变量的原子操作。
ABA问题
因为CAS需要在操作值的时候,检查值有没有发生变化,如果发生变化则更新,但是如果一个值为A,变成了B,又变成了A,那么使用CAS进行检查时就会发现它的值没有发生变化,但实际上发生变化了。ABA问题的解决思路就是使用版本号,在变量前边追加版本号,每次变量更新的时候把版本号加1,那么A→B→A就会变成1A→2B→3A。举个通俗点的例子,你倒了一杯水放桌子上,干了点别的事,然后同事把你水喝了又给你重新倒了一杯水,你回来看水还在,拿起来就喝,如果你不管水中间被人喝过,只关心水还在,这就是ABA问题。
从java1.5开始,JDK提供了AtomicStampedReference、AtomicMarkableReference来解决ABA的问题,通过compareAndSet方法检查值是否发生变化以外检查版本号知否发生变化。
循环时间长开销大
自旋CAS如果长时间不成功,会给CPU带来非常大的执行开销。
只能保证一个共享变量的原子操作
当对一个共享变量执行操作时,我们可以使用循环CAS的方式来保证原子操作,但是对多个共享变量操作时,循环CAS就无法保证操作的原子性,这个时候就可以用锁。
从Java 1.5开始,JDK提供了AtomicReference类来保证引用对象之间的原子性,就可以把多个变量放在一个对象里来进行CAS操作。