It took a little time looked at the source code, record a bit, here's what the record posted, and in front of the article there are some differences
public class AtomicInteger extends Number implements java.io.Serializable {
private static final long serialVersionUID = 6214790243416807050L;
// setup to use Unsafe.compareAndSwapInt for updates
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;
static {
try {
valueOffset = unsafe.objectFieldOffset
(java.util.concurrent.atomic.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);
}
/**
* var1是对象,var2是偏移量,var4是新值
*/
public final int getAndSetInt(Object var1, long var2, int var4) {
int var5;
do {
/**
* 通过对象和偏移量读取不经过缓存的值
* https://stackoverflow.com/questions/48615456/what-is-difference-between-getxxxvolatile-vs-getxxx-in-java-unsafe
*/
var5 = this.getIntVolatile(var1, var2);
/**
* 不成功会一直重试,并把原来的值返回
*/
} while(!this.compareAndSwapInt(var1, var2, var5, var4));
return var5;
}
/**
* 比对set
*/
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);
}
/**
* 加1,返回的是旧的值
*/
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
/**
* 减1,返回的是旧的值
*/
public final int getAndDecrement() {
return unsafe.getAndAddInt(this, valueOffset, -1);
}
/**
* 加1,返回的是新值
*/
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
/**
* 减1,返回的是新值
*/
public final int decrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
}
/**
* 增加的是固定的值,返回的是增加前的值
*/
public final int getAndAdd(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta);
}
/**
* 这是上边这几个方法的原生方法
*/
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}
/**
* addAndGet方法,addAndGet方法内部使用一个死循环,先得到当前的值value,然后再把当前的值加一,加完之后使用cas原子操作让当前值加一处理正确。
* 当然cas原子操作不一定是成功的,所以做了一个死循环,当cas操作成功的时候返回数据。这里由于使用了cas原子操作,所以不会出现多线程处理错误的问题。
* 比如线程A得到current为1,线程B也得到current为1;线程A的next值为2,进行cas操作并且成功的时候,将value修改成了2;这个时候线程B也得到next值为2,
* 当进行cas操作的时候由于expected值已经是2,而不是1了;所以cas操作会失败,下一次循环的时候得到的current就变成了2;也就不会出现多线程处理问题了
*/
public final int addAndGet(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
}
/**
*这个方法是 Java 1.8 开始提供的,这个方法自身返回当前值。
* 同时会把 updateFunction 的返回值设置为新值
*/
public final int getAndUpdate(IntUnaryOperator updateFunction) {
int prev, next;
do {
prev = get();
next = updateFunction.applyAsInt(prev);
} while (!compareAndSet(prev, next));
return prev;
}
/**
* 用法多线程环境下安全更新Integer i = ai.updateAndGet(x -> 5);
*/
public final int updateAndGet(IntUnaryOperator updateFunction) {
int prev, next;
do {
prev = get();
next = updateFunction.applyAsInt(prev);
} while (!compareAndSet(prev, next));
return next;
}
/**
* 1.8加入,多线程环境下安全更新 将原子值和传入的参数组合
* !compareAndSet(prev, next)这是一个竞态的条件,满足的时候才会更新
* compareAndSet相当于是原语的,原子操作
* 返回的是旧值
*/
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;
}
/**
* 1.8加入,多线程环境下安全更新 将原子值和传入的参数组合
* !compareAndSet(prev, next)这是一个竞态的条件,满足的时候才会更新
* compareAndSet相当于是原语的,原子操作
* 返回的是新值
*/
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;
}
/**
* 转String
*/
public String toString() {
return Integer.toString(get());
}
/**
* 获取值
*/
public int intValue() {
return get();
}
/**
* 强转long
*/
public long longValue() {
return (long)get();
}
/**
* 强转float
*/
public float floatValue() {
return (float)get();
}
/**
* 强转double
*/
public double doubleValue() {
return (double)get();
}