AtomicLong、AtomicBoolean等方法的原理和思想跟AtomicInteger基本相同，这里就主要说下AtomicInteger。
在并发编程时我们需要考虑三件事：
原子性
一个或多个操作，在执行中不会被任何其它任务或事件中断，就像数据库里面的事务，同生共死。
这一拜....春风得意遇知音....咳
可见性
当多个线程访问同一个变量时，一个线程对变量值的修改，能够及时被其他线程看到。
有序性
即程序执行的顺序按照代码的先后顺序执行
i++
举个例子：
当我们想要给网络请求日志加个Id的时候，可能会想到用i++的操作，但是这个自增操作是非线程安全的，
i++实际上可拆分为三步：
1.获取变量当前值
2.给获取的当前变量值+1
3.写回新的值到变量
因此在并发操作下得到的结果显然不是我们想要的。
AtomicInteger
源码
package java.util.concurrent.atomic;
import java.util.function.IntBinaryOperator;
import java.util.function.IntUnaryOperator;
public class AtomicInteger extends Number implements java.io.Serializable {
private static final long serialVersionUID = 6214790243416807050L;
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;
/**
* 使用给定的初始值创建一个新的AtomicInteger。
*
* @param initialValue the initial value
*/
public AtomicInteger(int initialValue) {
value = initialValue;
}
/**
* 创建一个新的AtomicInteger。
* 默认值为0
*/
public AtomicInteger() {
}
/**
* 获取当前 AtomicInteger 的值
*
* @return the current value
*/
public final int get() {
return value;
}
/**
* 设置当前 AtomicInteger 的值
*
* @param newValue the new value
*/
public final void set(int newValue) {
value = newValue;
}
/**
* 以普通变量的形式来读写变量
*
* @param newValue the new value
* @since 1.6
*/
public final void lazySet(int newValue) {
U.putOrderedInt(this, VALUE, newValue);
}
/**
* 以原子方式设置为给定值并返回旧值
*
* @param newValue the new value
* @return the previous value
*/
public final int getAndSet(int newValue) {
return U.getAndSetInt(this, VALUE, newValue);
}
/**
* 传说中的CAS
* 如果当前值等于 expect 的值，那么就以原子性的方式将当前值设置为 update 给定值，
* 这个方法会返回一个 boolean 类型，如果是 true 就表示比较并更新成功，否则表示失败
* if the current value {@code ==} the expected value.
*
* @param expect the expected value
* @param update the new value
* @return {@code true} if successful. False return indicates that
* the actual value was not equal to the expected value.
*/
public final boolean compareAndSet(int expect, int update) {
return U.compareAndSwapInt(this, VALUE, expect, update);
}
/**
* 跟compareAndSet 一毛一样，为啥有两个一样的方法？？
* if the current value {@code ==} the expected value.
* @param expect the expected value
* @param update the new value
* @return {@code true} if successful
*/
public final boolean weakCompareAndSet(int expect, int update) {
return U.compareAndSwapInt(this, VALUE, expect, update);
}
/**
* 先取旧值，然后自增
*
* @return the previous value
*/
public final int getAndIncrement() {
return U.getAndAddInt(this, VALUE, 1);
}
/**
* 先取旧值，然后自减
*
* @return the previous value
*/
public final int getAndDecrement() {
return U.getAndAddInt(this, VALUE, -1);
}
/**
* 先取旧值，然后加delta
*
* @param delta the value to add
* @return the previous value
*/
public final int getAndAdd(int delta) {
return U.getAndAddInt(this, VALUE, delta);
}
/**
* 先加1，然后获取新值
*
* @return the updated value
*/
public final int incrementAndGet() {
return U.getAndAddInt(this, VALUE, 1) + 1;
}
/**
* 先减1，然后获取新值
*
* @return the updated value
*/
public final int decrementAndGet() {
return U.getAndAddInt(this, VALUE, -1) - 1;
}
/**
* 先增加，然后获取新值
*
* @param delta the value to add
* @return the updated value
*/
public final int addAndGet(int delta) {
return U.getAndAddInt(this, VALUE, delta) + delta;
}
/**
* 先获取再更新，然后比较并设置值，
*
* @param updateFunction a side-effect-free function
* @return the previous value
* @since 1.8
*/
public final int getAndUpdate(IntUnaryOperator updateFunction) {
int prev, next;
do {
prev = get();
next = updateFunction.applyAsInt(prev);
} while (!compareAndSet(prev, next));
return prev;
}
/**
* 请自行理解，...白眼
*
* @param updateFunction a side-effect-free function
* @return the updated value
* @since 1.8
*/
public final int updateAndGet(IntUnaryOperator updateFunction) {
int prev, next;
do {
prev = get();
next = updateFunction.applyAsInt(prev);
} while (!compareAndSet(prev, next));
return next;
}
/**
* 请自行理解，...白眼
*
* @param x the update value
* @param accumulatorFunction a side-effect-free function of two arguments
* @return the previous value
* @since 1.8
*/
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;
}
/**
* 请自行理解，...白眼
*
* @param x the update value
* @param accumulatorFunction a side-effect-free function of two arguments
* @return the updated value
* @since 1.8
*/
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;
}
/**
* Returns the String representation of the current value.
* @return the String representation of the current value
*/
public String toString() {
return Integer.toString(get());
}
/**
* Returns the value of this {@code AtomicInteger} as an {@code int}.
* Equivalent to {@link #get()}.
*/
public int intValue() {
return get();
}
/**
* Returns the value of this {@code AtomicInteger} as a {@code long}
* after a widening primitive conversion.
* @jls 5.1.2 Widening Primitive Conversions
*/
public long longValue() {
return (long)get();
}
/**
* Returns the value of this {@code AtomicInteger} as a {@code float}
* after a widening primitive conversion.
* @jls 5.1.2 Widening Primitive Conversions
*/
public float floatValue() {
return (float)get();
}
/**
* Returns the value of this {@code AtomicInteger} as a {@code double}
* after a widening primitive conversion.
* @jls 5.1.2 Widening Primitive Conversions
*/
public double doubleValue() {
return (double)get();
}
}
使用
还能咋使用就“new”呗！方法用“.”调呗！