文章目录
原子(atomic)本意是“不能被进一步分割的最小粒子”,而原子操作(atomic operation)意为“不可被中断的一个或一系列操作”。在多处理器上实现原子操作就变得有点复杂。让我们一起来聊一聊在Intel处理器和Java里是如何实现原子操作的。
1 如何实现原子操作
-
使用总线锁保证原子性
举个栗子:如果i=1,我们进行两次
i++
操作,我们期望的结果是3,但是有可能结果是2处理器使用总线锁就是来解决这个问题的。
当一个处理器在总线上输出此信号时,其他处理器的请求将被阻塞住,那么该处理器可以独占共享内存。
缺点:总线锁定把CPU和内存之间的通信锁住了,这使得锁定期间,其他处理器不能操作其他内存地址的数据,所以总线锁定的开销比较大
-
使用缓存锁保证原子性
“缓存锁定”是指内存区域如果被缓存在处理器的缓存行中,并且在Lock操作期间被锁定,那么当它执行锁操作回写到内存时,处理器不在总线上声言LOCK#信号,而是修改内部的内存地址,并允许它的缓存一致性机制来保证操作的原子性
两种情况下处理器不会使用缓存锁定:
- 当操作的数据不能被缓存在处理器内部,或操作的数据跨多个缓存行->总线锁定
- 处理器不支持缓存锁定
2 Java如何实现原子操作
以下代码实现了一个基于 CAS 线程安全的计数器方法safeCount
和一个非线程安全的计数器count
。
public class CASTest {
private AtomicInteger atomicI = new AtomicInteger(0);
private int i = 0;
public static void main(String[] args) throws InterruptedException {
final CASTest cas = new CASTest();
List<Thread> ts = new ArrayList<Thread>(600);
long start = System.currentTimeMillis();
for (int j = 0; j < 100; j++) {
Thread t = new Thread(()->{
for (int i = 0; i < 10000; i++) {
cas.count();
cas.safeCount();
}
});
ts.add(t);
}
for (Thread t : ts) {
t.start();
}
// 等待所有线程执行完成
for (Thread t : ts) {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// TimeUnit.SECONDS.sleep(1);
System.out.println(cas.i);
System.out.println(cas.atomicI.get());
System.out.println(System.currentTimeMillis() - start);
}
/** * 使用CAS实现线程安全计数器 */
private void safeCount() {
for (;;) {
int i = atomicI.get();
boolean suc = atomicI.compareAndSet(i, ++i);
if (suc) {
break;
}
}
int i = atomicI.addAndGet(1);
}
/**
* 非线程安全计数器
*/
private void count() {
i++;
}
}
Output:
964857
2000000
219
2.1 CAS 实现原子操作的三大问题
-
ABA问题:
如果一个值原来是A,变成了B,又变成了A,那么使用CAS进行检查时会发现它的值没有发生变化.
解决方案:
JDK的Atomic包里提供了一个类
AtomicStampedReference
来解决ABA问题源码分析:
public boolean compareAndSet( V expectedReference, // 预期引用 V newReference, // 更新后的引用 int expectedStamp, // 预期标志 int newStamp // 更新后的标志 )
-
循环时间长开销大:
自旋 CAS 如果长时间不成功,会给CPU带来非常大的执行开销
-
只能保证一个共享变量的原子操作:
我们可以使用循环CAS的方式来保证原子操作,但是对多个共享变量操作时,循环CAS就无法保证操作的原子性,这个时候就可以用锁。
解决方案:
JDK提供了AtomicReference类来保证引用对象之间的原子性,就可以把多个变量放在一个对象里来进行CAS操作。
源码分析:
public class AtomicReference<V> implements java.io.Serializable { // 可以看出 value值可以为任意类型 private volatile V value; /** * Atomically updates the current value with the results of * applying the given function to the current and given values, * returning the previous value. The function should be * side-effect-free, since it may be re-applied when attempted * updates fail due to contention among threads. The function * is applied with the current value as its first argument, * and the given update as the second argument. * * @param x the update value * @param accumulatorFunction a side-effect-free function of two arguments * @return the previous value * @since 1.8 */ public final V getAndAccumulate(V x, BinaryOperator<V> accumulatorFunction) { V prev, next; do { prev = get(); next = accumulatorFunction.apply(prev, x); } while (!compareAndSet(prev, next)); return prev; } }
2.2 使用锁机制实现原子操作
锁机制保证了只有获得锁的线程才能够操作锁定的内存区域。
JVM内部实现了很多种锁机制,有偏向锁、轻量级锁和互斥锁。有意思的是除了偏向锁,JVM实现锁的方式都用了循环CAS,即当一个线程想进入同步块的时候使用循环CAS的方式来获取锁,当它退出同步块的时候使用循环CAS释放锁。
3 源码分析 ----- AtomicInteger
J.U.C
包里面的整数原子类 AtomicInteger
的方法调用了 Unsafe 类的 CAS 操作。
/**
* Atomically sets to the given value and returns the old value.
*
* @param newValue the new value
* @return the previous value
*/
public final int getAndSet(int newValue) {
return unsafe.getAndSetInt(this, valueOffset, newValue);
}
我们继续深入,看看getAndSetInt
是怎么实现的?
public final int getAndSetInt(Object var1, long var2, int var4) {
// var1为起始位置,var2为偏移量,通过v1,v2可以找到内存中的int值
int var5;
do {
// 获取内存中的值
var5 = this.getIntVolatile(var1, var2);
// 当 当前内存中的值与var5相同时,才进行swap操作
} while(!this.compareAndSwapInt(var1, var2, var5, var4));
return var5;
}