17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 */
24
25 /*
26 * This file is available under and governed by the GNU General Public
27 * License version 2 only, as published by the Free Software Foundation.
28 * However, the following notice accompanied the original version of this
29 * file:
30 *
31 * Written by Doug Lea with assistance from members of JCP JSR-166
32 * Expert Group and released to the public domain, as explained at
33 * http://creativecommons.org/publicdomain/zero/1.0/
34 */
35
36 package java.util.concurrent.atomic;
37 import sun.misc.Unsafe;
38
39 /**
40 * A {@code long} value that may be updated atomically. See the
41 * {@link java.util.concurrent.atomic} package specification for
42 * description of the properties of atomic variables. An
43 * {@code AtomicLong} is used in applications such as atomically
44 * incremented sequence numbers, and cannot be used as a replacement
45 * for a {@link java.lang.Long}. However, this class does extend
46 * {@code Number} to allow uniform access by tools and utilities that
47 * deal with numerically-based classes.
48 *
49 * @since 1.5
50 * @author Doug Lea
51 */
52 public class AtomicLong extends Number implements java.io.Serializable {
53 private static final long serialVersionUID = 1927816293512124184L;
54
55 // setup to use Unsafe.compareAndSwapLong for updates
56 private static final Unsafe unsafe = Unsafe.getUnsafe();
200
201 /**
202 * Atomically decrements by one the current value.
203 *
204 * @return the updated value
205 */
206 public final long decrementAndGet() {
207 return getAndAdd(-1) - 1;
208 }
209
210 /**
211 * Atomically adds the given value to the current value.
212 *
213 * @param delta the value to add
214 * @return the updated value
215 */
216 public final long addAndGet(long delta) {
217 return getAndAdd(delta) + delta;
218 }
219
220 /**
221 * Returns the String representation of the current value.
222 * @return the String representation of the current value
223 */
224 public String toString() {
225 return Long.toString(get());
226 }
227
228 /**
229 * Returns the value of this {@code AtomicLong} as an {@code int}
230 * after a narrowing primitive conversion.
231 * @jls 5.1.3 Narrowing Primitive Conversions
232 */
233 public int intValue() {
234 return (int)get();
235 }
236
237 /**
238 * Returns the value of this {@code AtomicLong} as a {@code long}.
239 */
|
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 */
24
25 /*
26 * This file is available under and governed by the GNU General Public
27 * License version 2 only, as published by the Free Software Foundation.
28 * However, the following notice accompanied the original version of this
29 * file:
30 *
31 * Written by Doug Lea with assistance from members of JCP JSR-166
32 * Expert Group and released to the public domain, as explained at
33 * http://creativecommons.org/publicdomain/zero/1.0/
34 */
35
36 package java.util.concurrent.atomic;
37 import java.util.function.LongUnaryOperator;
38 import java.util.function.LongBinaryOperator;
39 import sun.misc.Unsafe;
40
41 /**
42 * A {@code long} value that may be updated atomically. See the
43 * {@link java.util.concurrent.atomic} package specification for
44 * description of the properties of atomic variables. An
45 * {@code AtomicLong} is used in applications such as atomically
46 * incremented sequence numbers, and cannot be used as a replacement
47 * for a {@link java.lang.Long}. However, this class does extend
48 * {@code Number} to allow uniform access by tools and utilities that
49 * deal with numerically-based classes.
50 *
51 * @since 1.5
52 * @author Doug Lea
53 */
54 public class AtomicLong extends Number implements java.io.Serializable {
55 private static final long serialVersionUID = 1927816293512124184L;
56
57 // setup to use Unsafe.compareAndSwapLong for updates
58 private static final Unsafe unsafe = Unsafe.getUnsafe();
202
203 /**
204 * Atomically decrements by one the current value.
205 *
206 * @return the updated value
207 */
208 public final long decrementAndGet() {
209 return getAndAdd(-1) - 1;
210 }
211
212 /**
213 * Atomically adds the given value to the current value.
214 *
215 * @param delta the value to add
216 * @return the updated value
217 */
218 public final long addAndGet(long delta) {
219 return getAndAdd(delta) + delta;
220 }
221
222 /**
223 * Atomically updates the current value with the results of
224 * applying the given function. The function should be
225 * side-effect-free, since it may be re-applied when attempted
226 * updates fail due to contention among threads.
227 *
228 * @param updateFunction a side-effect-free function
229 * @return the previous value
230 * @since 1.8
231 */
232 public final long getAndUpdate(LongUnaryOperator updateFunction) {
233 long prev, next;
234 do {
235 prev = get();
236 next = updateFunction.operateAsLong(prev);
237 } while (!compareAndSet(prev, next));
238 return prev;
239 }
240
241 /**
242 * Atomically updates the current value with the results of
243 * applying the given function. The function should be
244 * side-effect-free, since it may be re-applied when attempted
245 * updates fail due to contention among threads.
246 *
247 * @param updateFunction a side-effect-free function
248 * @return the updated value
249 * @since 1.8
250 */
251 public final long updateAndGet(LongUnaryOperator updateFunction) {
252 long prev, next;
253 do {
254 prev = get();
255 next = updateFunction.operateAsLong(prev);
256 } while (!compareAndSet(prev, next));
257 return next;
258 }
259
260 /**
261 * Atomically updates the current value with the results of
262 * applying the given function to the current and given values.
263 * The function should be side-effect-free, since it may be
264 * re-applied when attempted updates fail due to contention among
265 * threads. The function is applied with the current value as its
266 * first argument, and the given update as the second argument.
267 *
268 * @param x the update value
269 * @param accumulatorFunction a side-effect-free function of two arguments
270 * @return the previous value
271 * @since 1.8
272 */
273 public final long getAndAccumulate(long x,
274 LongBinaryOperator accumulatorFunction) {
275 long prev, next;
276 do {
277 prev = get();
278 next = accumulatorFunction.operateAsLong(prev, x);
279 } while (!compareAndSet(prev, next));
280 return prev;
281 }
282
283 /**
284 * Atomically updates the current value with the results of
285 * applying the given function to the current and given values.
286 * The function should be side-effect-free, since it may be
287 * re-applied when attempted updates fail due to contention among
288 * threads. The function is applied with the current value as its
289 * first argument, and the given update as the second argument.
290 *
291 * @param x the update value
292 * @param accumulatorFunction a side-effect-free function of two arguments
293 * @return the updated value
294 * @since 1.8
295 */
296 public final long accumulateAndGet(long x,
297 LongBinaryOperator accumulatorFunction) {
298 long prev, next;
299 do {
300 prev = get();
301 next = accumulatorFunction.operateAsLong(prev, x);
302 } while (!compareAndSet(prev, next));
303 return next;
304 }
305
306 /**
307 * Returns the String representation of the current value.
308 * @return the String representation of the current value
309 */
310 public String toString() {
311 return Long.toString(get());
312 }
313
314 /**
315 * Returns the value of this {@code AtomicLong} as an {@code int}
316 * after a narrowing primitive conversion.
317 * @jls 5.1.3 Narrowing Primitive Conversions
318 */
319 public int intValue() {
320 return (int)get();
321 }
322
323 /**
324 * Returns the value of this {@code AtomicLong} as a {@code long}.
325 */
|