AtomicLong介紹和函數列表
AtomicLong是作用是對長整形進行原子操作。
在32位操作系統中，64位的long 和 double 變量由于會被JVM當作兩個分離的32位來進行操作，所以不具有原子性。而使用AtomicLong能讓long的操作保持原子型。
AtomicLong函數列表
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
// 構造函數AtomicLong()// 創建值為initialValue的AtomicLong對象AtomicLong(long initialValue)// 以原子方式設置當前值為newValue。final void set(long newValue) // 獲取當前值final long get() // 以原子方式將當前值減 1，并返回減1后的值。等價于“--num”final long decrementAndGet() // 以原子方式將當前值減 1，并返回減1前的值。等價于“num--”final long getAndDecrement() // 以原子方式將當前值加 1，并返回加1后的值。等價于“++num”final long incrementAndGet() // 以原子方式將當前值加 1，并返回加1前的值。等價于“num++”final long getAndIncrement() // 以原子方式將delta與當前值相加，并返回相加后的值。final long addAndGet(long delta) // 以原子方式將delta添加到當前值，并返回相加前的值。final long getAndAdd(long delta) // 如果當前值 == expect，則以原子方式將該值設置為update。成功返回true，否則返回false，并且不修改原值。final boolean compareAndSet(long expect, long update)// 以原子方式設置當前值為newValue，并返回舊值。final long getAndSet(long newValue)// 返回當前值對應的int值int intValue() // 獲取當前值對應的long值long longValue() // 以 float 形式返回當前值float floatValue() // 以 double 形式返回當前值double doubleValue() // 最后設置為給定值。延時設置變量值，這個等價于set()方法，但是由于字段是volatile類型的，因此次字段的修改會比普通字段（非volatile字段）有稍微的性能延時（盡管可以忽略），所以如果不是想立即讀取設置的新值，允許在“后臺”修改值，那么此方法就很有用。如果還是難以理解，這里就類似于啟動一個后臺線程如執行修改新值的任務，原線程就不等待修改結果立即返回（這種解釋其實是不正確的，但是可以這么理解）。final void lazySet(long newValue)// 如果當前值 == 預期值，則以原子方式將該設置為給定的更新值。JSR規范中說：以原子方式讀取和有條件地寫入變量但不 創建任何 happen-before 排序，因此不提供與除 weakCompareAndSet 目標外任何變量以前或后續讀取或寫入操作有關的任何保證。大意就是說調用weakCompareAndSet時并不能保證不存在happen-before的發生（也就是可能存在指令重排序導致此操作失敗）。但是從Java源碼來看，其實此方法并沒有實現JSR規范的要求，最后效果和compareAndSet是等效的，都調用了unsafe.compareAndSwapInt()完成操作。final boolean weakCompareAndSet(long expect, long update) |
AtomicLong源碼分析(基于JDK1.7.0_40)
AtomicLong的完整源碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
|
/* * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * *//* * * * * * * Written by Doug Lea with assistance from members of JCP JSR- * Expert Group and released to the public domain, as explained at * http://creativecommons.org/publicdomain/zero/./ */package java.util.concurrent.atomic;import sun.misc.Unsafe;/** * A {@code long} value that may be updated atomically. See the * {@link java.util.concurrent.atomic} package specification for * description of the properties of atomic variables. An * {@code AtomicLong} is used in applications such as atomically * incremented sequence numbers, and cannot be used as a replacement * for a {@link java.lang.Long}. However, this class does extend * {@code Number} to allow uniform access by tools and utilities that * deal with numerically-based classes. * * @since . * @author Doug Lea */public class AtomicLong extends Number implements java.io.Serializable { private static final long serialVersionUID = L; // setup to use Unsafe.compareAndSwapLong for updates private static final Unsafe unsafe = Unsafe.getUnsafe(); private static final long valueOffset; /** * Records whether the underlying JVM supports lockless * compareAndSwap for longs. While the Unsafe.compareAndSwapLong * method works in either case, some constructions should be * handled at Java level to avoid locking user-visible locks. */ static final boolean VM_SUPPORTS_LONG_CAS = VMSupportsCS(); /** * Returns whether underlying JVM supports lockless CompareAndSet * for longs. Called only once and cached in VM_SUPPORTS_LONG_CAS. */ private static native boolean VMSupportsCS(); static { try { valueOffset = unsafe.objectFieldOffset (AtomicLong.class.getDeclaredField("value")); } catch (Exception ex) { throw new Error(ex); } } private volatile long value; /** * Creates a new AtomicLong with the given initial value. * * @param initialValue the initial value */ public AtomicLong(long initialValue) { value = initialValue; } /** * Creates a new AtomicLong with initial value {@code }. */ public AtomicLong() { } /** * Gets the current value. * * @return the current value */ public final long get() { return value; } /** * Sets to the given value. * * @param newValue the new value */ public final void set(long newValue) { value = newValue; } /** * Eventually sets to the given value. * * @param newValue the new value * @since 1.6 */ public final void lazySet(long newValue) { unsafe.putOrderedLong(this, valueOffset, newValue); } /** * Atomically sets to the given value and returns the old value. * * @param newValue the new value * @return the previous value */ public final long getAndSet(long newValue) { while (true) { long current = get(); if (compareAndSet(current, newValue)) return current; } } /** * Atomically sets the value to the given updated value * if the current value {@code ==} the expected value. * * @param expect the expected value * @param update the new value * @return true if successful. False return indicates that * the actual value was not equal to the expected value. */ public final boolean compareAndSet(long expect, long update) { return unsafe.compareAndSwapLong(this, valueOffset, expect, update); } /** * Atomically sets the value to the given updated value * if the current value {@code ==} the expected value. * * <p>May <a href="package-summary.html#Spurious" rel="external nofollow" >fail spuriously</a> * and does not provide ordering guarantees, so is only rarely an * appropriate alternative to {@code compareAndSet}. * * @param expect the expected value * @param update the new value * @return true if successful. */ public final boolean weakCompareAndSet(long expect, long update) { return unsafe.compareAndSwapLong(this, valueOffset, expect, update); } /** * Atomically increments by one the current value. * * @return the previous value */ public final long getAndIncrement() { while (true) { long current = get(); long next = current + 1; if (compareAndSet(current, next)) return current; } } /** * Atomically decrements by one the current value. * * @return the previous value */ public final long getAndDecrement() { while (true) { long current = get(); long next = current - 1; if (compareAndSet(current, next)) return current; } } /** * Atomically adds the given value to the current value. * * @param delta the value to add * @return the previous value */ public final long getAndAdd(long delta) { while (true) { long current = get(); long next = current + delta; if (compareAndSet(current, next)) return current; } } /** * Atomically increments by one the current value. * * @return the updated value */ public final long incrementAndGet() { for (;;) { long current = get(); long next = current + 1; if (compareAndSet(current, next)) return next; } } /** * Atomically decrements by one the current value. * * @return the updated value */ public final long decrementAndGet() { for (;;) { long current = get(); long next = current - 1; if (compareAndSet(current, next)) return next; } } /** * Atomically adds the given value to the current value. * * @param delta the value to add * @return the updated value */ public final long addAndGet(long delta) { for (;;) { long current = get(); long next = current + delta; if (compareAndSet(current, next)) return next; } } /** * Returns the String representation of the current value. * @return the String representation of the current value. */ public String toString() { return Long.toString(get()); } public int intValue() { return (int)get(); } public long longValue() { return get(); } public float floatValue() { return (float)get(); } public double doubleValue() { return (double)get(); }} |
AtomicLong的代碼很簡單，下面僅以incrementAndGet()為例，對AtomicLong的原理進行說明。
incrementAndGet()源碼如下：
|
1
2
3
4
5
6
7
8
9
10
11
|
public final long incrementAndGet() { for (;;) { // 獲取AtomicLong當前對應的long值 long current = get(); // 將current加1 long next = current + 1; // 通過CAS函數，更新current的值 if (compareAndSet(current, next)) return next; }} |
說明：
(01) incrementAndGet()首先會根據get()獲取AtomicLong對應的long值。該值是volatile類型的變量，get()的源碼如下：
|
1
2
3
4
5
6
|
// value是AtomicLong對應的long值private volatile long value;// 返回AtomicLong對應的long值public final long get() { return value;} |
(02) incrementAndGet()接著將current加1,然后通過CAS函數，將新的值賦值給value。
compareAndSet()的源碼如下：
|
1
2
3
|
public final boolean compareAndSet(long expect, long update) { return unsafe.compareAndSwapLong(this, valueOffset, expect, update);} |
compareAndSet()的作用是更新AtomicLong對應的long值。它會比較AtomicLong的原始值是否與expect相等，若相等的話，則設置AtomicLong的值為update。
AtomicLong示例
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
// LongTest.java的源碼import java.util.concurrent.atomic.AtomicLong;public class LongTest { public static void main(String[] args){ // 新建AtomicLong對象 AtomicLong mAtoLong = new AtomicLong(); mAtoLong.set(0x0123456789ABCDEFL); System.out.printf("%20s : 0x%016X\n", "get()", mAtoLong.get()); System.out.printf("%20s : 0x%016X\n", "intValue()", mAtoLong.intValue()); System.out.printf("%20s : 0x%016X\n", "longValue()", mAtoLong.longValue()); System.out.printf("%20s : %s\n", "doubleValue()", mAtoLong.doubleValue()); System.out.printf("%20s : %s\n", "floatValue()", mAtoLong.floatValue()); System.out.printf("%20s : 0x%016X\n", "getAndDecrement()", mAtoLong.getAndDecrement()); System.out.printf("%20s : 0x%016X\n", "decrementAndGet()", mAtoLong.decrementAndGet()); System.out.printf("%20s : 0x%016X\n", "getAndIncrement()", mAtoLong.getAndIncrement()); System.out.printf("%20s : 0x%016X\n", "incrementAndGet()", mAtoLong.incrementAndGet()); System.out.printf("%20s : 0x%016X\n", "addAndGet(0x10)", mAtoLong.addAndGet(0x10)); System.out.printf("%20s : 0x%016X\n", "getAndAdd(0x10)", mAtoLong.getAndAdd(0x10)); System.out.printf("\n%20s : 0x%016X\n", "get()", mAtoLong.get()); System.out.printf("%20s : %s\n", "compareAndSet()", mAtoLong.compareAndSet(0x12345679L, 0xFEDCBA9876543210L)); System.out.printf("%20s : 0x%016X\n", "get()", mAtoLong.get()); }} |
運行結果：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
get() : 0x0123456789ABCDEF intValue() : 0x0000000089ABCDEF longValue() : 0x0123456789ABCDEF doubleValue() : 8.1985529216486896E16 floatValue() : 8.1985531E16getAndDecrement() : 0x0123456789ABCDEFdecrementAndGet() : 0x0123456789ABCDEDgetAndIncrement() : 0x0123456789ABCDEDincrementAndGet() : 0x0123456789ABCDEF addAndGet(0x10) : 0x0123456789ABCDFF getAndAdd(0x10) : 0x0123456789ABCDFF get() : 0x0123456789ABCE0F compareAndSet() : false get() : 0x0123456789ABCE0F |
以上所述是小編給大家介紹的Java concurrency之AtomicLong原子類，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復大家的。在此也非常感謝大家對服務器之家網站的支持！
