首页 > 代码库 > J.U.C中的原子变量

J.U.C中的原子变量

  在开发过程中,很多时候都需要用到原子的递增递减操作;而我们知道,常用的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 = http://www.mamicode.com/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 =http://www.mamicode.com/= 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 =http://www.mamicode.com/= 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 =http://www.mamicode.com/ 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 =http://www.mamicode.com/ 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 }

 

J.U.C中的原子变量