为什么需要AtomicInteger原子操作类?
很多时候我们都用到 num++,若没有加synchronized关键字则是线程不安全的,num++解析为num=num+1,明显,这个操作不具备原子性,多线程时必然会出现问题,测试下:
public class AtomicIntegerTest {
public static int num = 0;
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(){
@Override
public void run(){
for (int j = 0; j < 100; j++) {
System.out.println(num++);
}
}
}.start();
}
}
}
结果:
这个值不定,每次测试都可能不一样,很显然,100个线程跑++操作,结果并没有像预期的那样num: 9999。
用了AtomicInteger类后会变成什么样子呢?
public class AtomicIntegerTest {
public static void main(String[] args) {
//从内部类中访问本地变量num; 需要被声明为最终类型
final AtomicInteger num = new AtomicInteger();
for (int i = 0; i < 100; i++) {
new Thread(){
@Override
public void run(){
for (int j = 0; j < 100; j++) {
System.out.println(num.getAndIncrement());
}
}
}.start();
}
}
}
结果:
没有失望,测试多次都是这个结果
学着其他大佬看看源码,虽然看的懵懵懂懂,多看看总是好的
package java.util.concurrent.atomic;
import java.util.function.IntUnaryOperator;
import java.util.function.IntBinaryOperator;
import sun.misc.Unsafe;
public class AtomicInteger extends Number implements java.io.Serializable {
private static final long serialVersionUID = 6214790243416807050L;
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;
static {
try {
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
private volatile int value;
public AtomicInteger(int initialValue) {
value = initialValue;
}
public AtomicInteger() {
}
public final int get() {
return value;
}
public final void set(int newValue) {
value = newValue;
}
public final void lazySet(int newValue) {
unsafe.putOrderedInt(this, valueOffset, newValue);
}
public final int getAndSet(int newValue) {
return unsafe.getAndSetInt(this, valueOffset, newValue);
}
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
public final boolean weakCompareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
public final int getAndDecrement() {
return unsafe.getAndAddInt(this, valueOffset, -1);
}
public final int getAndAdd(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta);
}
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
public final int decrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
}
public final int addAndGet(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
}
public final int getAndUpdate(IntUnaryOperator updateFunction) {
int prev, next;
do {
prev = get();
next = updateFunction.applyAsInt(prev);
} while (!compareAndSet(prev, next));
return prev;
}
public final int updateAndGet(IntUnaryOperator updateFunction) {
int prev, next;
do {
prev = get();
next = updateFunction.applyAsInt(prev);
} while (!compareAndSet(prev, next));
return next;
}
public final int getAndAccumulate(int x,
IntBinaryOperator accumulatorFunction) {
int prev, next;
do {
prev = get();
next = accumulatorFunction.applyAsInt(prev, x);
} while (!compareAndSet(prev, next));
return prev;
}
public final int accumulateAndGet(int x,
IntBinaryOperator accumulatorFunction) {
int prev, next;
do {
prev = get();
next = accumulatorFunction.applyAsInt(prev, x);
} while (!compareAndSet(prev, next));
return next;
}
public String toString() {
return Integer.toString(get());
}
public int intValue() {
return get();
}
public long longValue() {
return (long)get();
}
public float floatValue() {
return (float)get();
}
public double doubleValue() {
return (double)get();
}
}
Value的定义和volatile
AtomicInteger 本身是个整型,所以最重要的属性就是value,我们看看它是如何声明value的
private volatile int value;
使用了volatile修饰,看到这个,对于我这个小菜来说,啥啊这是
通过了解知道,volatile相当于synchronized
的弱实现,也就是说volatile
实现了类似synchronized
的语义,却又没有锁机制。它确保对volatile
字段的更新以可预见的方式告知其他的线程。这样,当一个线程修改了这个值后,其他线程可以读取到修改后的值
用CAS(Compare and Swap)操作实现安全的自增
看下incrementAndGet()是如何实现的
public final int incrementAndGet() {
for (;;) {
int current = get();
int next = current + 1;
if (compareAndSet(current, next))
return next;
}
}
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
AtomicInteger 中的CAS操作就是compareAndSet()
,其作用是每次从内存中根据内存偏移量(valueOffset
)取出数据,将取出的值跟expect 比较,如果数据一致就把内存中的值改为update,这样使用CAS就保证了原子操作。
总结
总结一下,AtomicInteger 中主要实现了整型的原子操作,防止并发情况下出现异常结果,其内部主要依靠JDK 中的unsafe 类操作内存中的数据来实现的。volatile 修饰符保证了value在内存中其他线程可以看到其值得改变。CAS操作保证了AtomicInteger 可以安全的修改value 的值。