在开发过程中，很多时候都需要用到原子的递增递减操作；而我们知道，常用的i ++ 和 i -- 等操作都不是原子的，它包含了三步操作（读-改-写）：首先，读取变量i的值，其次将i执行 +1 或者 -1 操作，最后，将计算后的结果赋值给i；通常情况下，只有加锁才能保证 i ++ 和 i -- 等操作的原子性。值得关注的是，在JDK1.5及之后的所有版本，java.concurrent.util.atomic包下给我们提供了原子变量，原子变量支持原子的递增和递减操作。这里，针对原子变量的底层实现原理及jdk的部分源码，做一些简单的记录。
1:AtomicBoolean，值得注意的是，AtomicBoolean使用了int类型的属性value来表示true和false，在设置、获取及修改的时候，都是针对value的操作。
其中，AtomicLong、AtomicInteger源码与AtomicBoolean相差不大，所以这里不再赘述。
/**
* @Comment AtomicBoolean部分源码
*/
public class AtomicBoolean implements Serializable {
/**
* sun.misc.Unsafe类
*/
private static final Unsafe unsafe = Unsafe.getUnsafe() ;
/**
* 属性value的偏移量
*/
private static final long valueOffset ;
/**
* 使用int类型value来表示true和false
* 1 - true 0 - false * volatile 修饰，可以保证value的可见性； * 即：如果一个线程对value进行了修改，会立马同步到主内存；同时其它线程的本地内存失效，直接读取主内存获取value的值。
*/
private volatile int value ;
static {
try {
//获取AtomicBoolean中value属性的内存地址偏移量
valueOffset = unsafe.objectFieldOffset(AtomicBoolean.class.getDeclaredField("value")) ;
} catch (Exception e) {
throw new Error(e) ;
}
}
/**
* 初始化 true-1 false-0
* @param initiavlValue
*/
public AtomicBoolean(boolean initiavlValue){
this.value = initiavlValue ? 1 : 0 ;
}
public AtomicBoolean(){}
/**
* 获取当前值
* @return
*/
public final boolean get(){
return value != 0 ;
}
/**
* 原子的更新
* @param expect 期望值
* @param update 修改值
* @return
*/
public final boolean compareAndSet(boolean expect , boolean update){
int e = expect ? 1 : 0 ;
int u = update ? 1 : 0 ;
//原子的修改value的值,如果value == e ; 修改为u ;否则不修改 ; 返回是否修改成功
return unsafe.compareAndSwapInt(this , valueOffset , e , u) ;
}
/**
* 原子的更新
* @param expect 期望值
* @param update 修改值
* @return
*/
public final boolean weakCompareAndSet(boolean expect , boolean update){
int e = expect ? 1 : 0 ;
int u = update ? 1 : 0 ;
//原子的修改value的值,如果value == e ; 修改为u ;否则不修改 ; 返回是否修改成功
return unsafe.compareAndSwapInt(this , valueOffset , e , u) ;
}
/**
* 设置value的值
* @param newValue
*/
public final void set(boolean newValue){
value = newValue ? 1 : 0 ;
}
/**
* 最终设置值
* @param newValue
*/
public final void lazySet(boolean newValue){
int v = newValue ? 1 : 0 ;
unsafe.putOrderedInt(this , valueOffset , v) ;
}
/**
* 获取老值,设置新值
* @param newValue
* @return
*/
public final boolean getAndSet(boolean newValue){
boolean prev ;
do {
prev = get() ;
}while (!compareAndSet(prev , newValue)) ;
return prev ;
}
public String toString(){
return Boolean.toString(get()) ;
}
}
2:AtomicIntegerArray
1 /**
2 * @Comment AtomicIntegerArray部分源码
3 */
4 public class AtomicIntegerArray implements Serializable {
5
6 private static final Unsafe unsafe = Unsafes.get() ;
7 /**
8 * 对象分配时,获取int类型数组的第一个元素的内存地址
9 * 即:相对于数组对象起始地址的偏移地址
10 */
11 private static final int base = unsafe.arrayBaseOffset(int[].class) ;
12 /**
13 * shift就是用来定位数组中的内存位置，用来移位用的;每向左移动移位，在不越界的情况下，想当于乘以2。
14 * 由于int类型的长度为4，所以,数组第0个角标开始位是0，第1(i)个角标开始位是4,，第二个(i)位置是8，
15 * 也就是偏移位置等于 i * 4,也就是 i << 2;总结出一个乘法转换成移位操作的案例：
16 * a * (一个2的幂(n)的数) = a << n; 给出一个指定2的幂的数，怎么算成n,,参照shift的计算方法
17 */
18 private static final int shift ;
19 /**
20 * int[]数组,在构造函数中初始化
21 */
22 private final int[] array ;
23
24 /**
25 * 1: unsafe.arrayIndexScale(int[].class) ;
26 * 标识int数组类型中元素占用字节的个数.
27 * 2: if( ( scale & (scale - 1) ) != 0 ) ;
28 * 验证元素占用的字节是否为2的n次幂
29 * 3: Integer.numberOfLeadingZeros(scale) ;
30 * 标识int类型的scale转换为2进制存储时,前边补0的个数
31 * 31 - Integer.numberOfLeadingZeros(scale) (这里跟内存操作相关,暂时没搞懂为什么用31减...)
32 */
33 static {
34 int scale = unsafe.arrayIndexScale(int[].class) ;
35 if( ( scale & (scale - 1) ) != 0 ){
36 throw new Error("data type scale not a power of two") ;
37 }
38 shift = 31 - Integer.numberOfLeadingZeros(scale) ;
39 }
40 /**
41 * 判断角标是否越界
42 * @param i
43 * @return
44 */
45 private long checkedByteOffset(int i){
46 if(i < 0 || i >= array.length)
47 throw new IndexOutOfBoundsException("index" + i) ;
48 return byteOffset(i) ;
49 }
50 /**
51 * 返回数组中第i个角标存储的元素的地址偏移量
52 * @param i
53 * @return
54 */
55 private static long byteOffset(int i){
56 return (long) (i << shift) + base ;
57 }
58 /**
59 * 根据长度,构造int[]
60 * @param length
61 */
62 public AtomicIntegerArray(int length){
63 this.array = new int[length] ;
64 }
65 /**
66 * 根据传入的数组,构造int[]
67 * @param array
68 */
69 public AtomicIntegerArray(int [] array){
70 this.array = array.clone() ;
71 }
72 /**
73 * 获取int[]的长度
74 * @return
75 */
76 public final int length(){
77 return array.length ;
78 }
79 /**
80 * 获取数组的第i个元素
81 * @param i
82 * @return
83 */
84 public final int get(int i){
85 return getRaw(i) ;
86 }
87 /**
88 * 获取array第offset角标的值
89 * @param offset
90 * @return
91 */
92 private int getRaw(long offset){
93 return unsafe.getIntVolatile(array , offset) ;
94 }
95 /**
96 * 将第i个角标的值设置为新值
97 * @param i
98 * @param newValue
99 */
100 public final void set(int i , int newValue){
101 unsafe.putIntVolatile(array , checkedByteOffset(i) , newValue) ;
102 }
103 /**
104 * 延迟设置值
105 * @param i
106 * @param newValue
107 */
108 public final void lazySet(int i , int newValue){
109 unsafe.putOrderedInt(this , checkedByteOffset(i) , newValue) ;
110 }
111 /**
112 * 获取并设置值
113 * @return
114 */
115 public final int getAndSet(int i , int newValue){
116 return unsafe.getAndSetInt(this , checkedByteOffset(i) , newValue) ;
117 }
118 /**
119 * 先比较,后设置
120 * @param i
121 * @param expect
122 * @param update
123 * @return
124 */
125 public final boolean compareAndSet(int i , int expect , int update){
126 return compareAndSetRaw(checkedByteOffset(i) , expect , update) ;
127 }
128 private boolean compareAndSetRaw(long offset , int expect , int update){
129 return unsafe.compareAndSwapInt(array , offset , expect , update) ;
130 }
131 public final boolean weakCompareAndSet(int i , int expect , int update){
132 return compareAndSet(i , expect , update) ;
133 }
134 /**
135 * 线程安全的递增
136 * @param i
137 * @return
138 */
139 public final int getAndIncrement(int i){
140 return getAndAdd(i, 1) ;
141 }
142 /**
143 * 线程安全的递减
144 * @param i
145 * @return
146 */
147 public final int getAndDecrement(int i){
148 return getAndAdd(i , -1) ;
149 }
150 /**
151 * 为角标为i的元素 加 delta
152 * @param i
153 * @param delta
154 * @return
155 */
156 public final int getAndAdd(int i , int delta){
157 return unsafe.getAndAddInt(array , checkedByteOffset(i) , delta) ;
158 }
159 /**
160 * 线程安全的递增,并获取递增后的值
161 * @return
162 */
163 public final int incrementAndGet(int i){
164 return getAndAdd(i , 1) + 1 ;
165 }
166 /**
167 * 线程安全的获取递减后的值
168 * @param i
169 * @return
170 */
171 public final int decrementAndGet(int i){
172 return getAndAdd(i , -1) - 1 ;
173 }
174 public final int addAndGet(int i , int delta){
175 return getAndAdd(i , delta) + delta ;
176 }
177
178 @Override
179 public String toString() {
180 int iMax = array.length - 1 ;
181 if(iMax == -1){
182 return "[]" ;
183 }
184 StringBuilder b = new StringBuilder() ;
185 b.append(‘[‘) ;
186 //两个;;之间没有判断,计算机可以少一步计算,提高性能
187 for(int i = 0 ; ; i ++){
188 b.append(getRaw(byteOffset(i))) ;
189 if(i == iMax){
190 return b.append(‘]‘).toString() ;
191 }
192 b.append(‘,‘).append(‘ ‘) ;
193 }
194 }
195 }
3:AtomicReference
1 /**
2 * @Comment AtomicReference部分源码 5 */
6 public class AtomicReference<V> implements Serializable {
7
8 private static final Unsafe unsafe = Unsafe.getUnsafe() ;
9 /**
10 * 对象地址
11 */
12 private static final long valueOffset ;
13 /**
14 * 待操作对象
15 */
16 private volatile V value ;
17 static {
18 try {
19 valueOffset = unsafe.objectFieldOffset(AtomicReference.class.getDeclaredField("value")) ;
20 }catch (Exception e){
21 throw new Error(e) ;
22 }
23 }
24
25 /**
26 * 构造器
27 * @param initValue
28 */
29 public AtomicReference(V initValue){
30 this.value = initValue ;
31 }
32 public AtomicReference(){}
33
34 /**
35 * 获取当前value
36 * @return
37 */
38 public final V get(){
39 return this.value ;
40 }
41 /**
42 * 设置当前value
43 * @param newValue
44 */
45 public final void set(V newValue){
46 this.value = newValue ;
47 }
48 /**
49 * 延迟设置
50 * @param newValue
51 */
52 public final void lazySet(V newValue){
53 unsafe.putOrderedObject(this , valueOffset , newValue);
54 }
55 /**
56 * 如果对象为期望对象,原子的替换为给定的对象
57 * @param expect
58 * @param update
59 * @return
60 */
61 public final boolean compareAndSet(V expect , V update){
62 return unsafe.compareAndSwapObject(this , valueOffset , expect , update) ;
63 }
64 /**
65 * 如果对象为期望对象,原子的替换为给定的对象
66 * @param expect
67 * @param update
68 * @return
69 */
70 public final boolean weakCompareAndSet(V expect , V update){
71 return unsafe.compareAndSwapObject(this , valueOffset , expect , update) ;
72 }
73 /**
74 * 原子的设置
75 * @param newValue
76 * @return
77 */
78 public final V getAndSet(V newValue){
79 return (V) unsafe.getAndSetObject(this , valueOffset , newValue) ;
80 }
81 @Override
82 public String toString() {
83 return String.valueOf(get()) ;
84 }
85 }
时间： 2024-11-11 04:37:17