AtomicLong、AtomicBoolean等方法的原理和思想跟AtomicInteger基本相同便贵，這里就主要說下AtomicInteger菠镇。
在并發(fā)編程時我們需要考慮三件事：
原子性
一個或多個操作，在執(zhí)行中不會被任何其它任務(wù)或事件中斷承璃，就像數(shù)據(jù)庫里面的事務(wù)利耍，同生共死。
這一拜....春風(fēng)得意遇知音....咳
可見性
當(dāng)多個線程訪問同一個變量時盔粹，一個線程對變量值的修改隘梨，能夠及時被其他線程看到。
有序性
即程序執(zhí)行的順序按照代碼的先后順序執(zhí)行
i++
舉個例子：
當(dāng)我們想要給網(wǎng)絡(luò)請求日志加個Id的時候舷嗡，可能會想到用i++的操作轴猎，但是這個自增操作是非線程安全的，
i++實際上可拆分為三步：
1.獲取變量當(dāng)前值
2.給獲取的當(dāng)前變量值+1
3.寫回新的值到變量
因此在并發(fā)操作下得到的結(jié)果顯然不是我們想要的进萄。
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;
/**
* 使用給定的初始值創(chuàng)建一個新的AtomicInteger捻脖。
*
* @param initialValue the initial value
*/
public AtomicInteger(int initialValue) {
value = initialValue;
}
/**
* 創(chuàng)建一個新的AtomicInteger锐峭。
* 默認(rèn)值為0
*/
public AtomicInteger() {
}
/**
* 獲取當(dāng)前 AtomicInteger 的值
*
* @return the current value
*/
public final int get() {
return value;
}
/**
* 設(shè)置當(dāng)前 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);
}
/**
* 以原子方式設(shè)置為給定值并返回舊值
*
* @param newValue the new value
* @return the previous value
*/
public final int getAndSet(int newValue) {
return U.getAndSetInt(this, VALUE, newValue);
}
/**
* 傳說中的CAS
* 如果當(dāng)前值等于 expect 的值，那么就以原子性的方式將當(dāng)前值設(shè)置為 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;
}
/**
* 先獲取再更新剂习，然后比較并設(shè)置值，
*
* @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”唄尸曼！方法用“.”調(diào)唄们何！
