jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicInteger.java
author shade
Fri, 25 Mar 2016 15:35:43 +0300
changeset 36936 bfcdf736a998
parent 33674 566777f73c32
child 39725 9548f8d846e9
permissions -rw-r--r--
8152698: Remove obsolete Unsafe.putOrdered{X} methods, usages, runtime and compiler support Reviewed-by: kvn, psandoz, dl
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     1
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
     2
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
90ce3da70b43 Initial load
duke
parents:
diff changeset
     3
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
     4
 * This code is free software; you can redistribute it and/or modify it
90ce3da70b43 Initial load
duke
parents:
diff changeset
     5
 * under the terms of the GNU General Public License version 2 only, as
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 2
diff changeset
     6
 * published by the Free Software Foundation.  Oracle designates this
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     7
 * particular file as subject to the "Classpath" exception as provided
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 2
diff changeset
     8
 * by Oracle in the LICENSE file that accompanied this code.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     9
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    10
 * This code is distributed in the hope that it will be useful, but WITHOUT
90ce3da70b43 Initial load
duke
parents:
diff changeset
    11
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
90ce3da70b43 Initial load
duke
parents:
diff changeset
    12
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
90ce3da70b43 Initial load
duke
parents:
diff changeset
    13
 * version 2 for more details (a copy is included in the LICENSE file that
90ce3da70b43 Initial load
duke
parents:
diff changeset
    14
 * accompanied this code).
90ce3da70b43 Initial load
duke
parents:
diff changeset
    15
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    16
 * You should have received a copy of the GNU General Public License version
90ce3da70b43 Initial load
duke
parents:
diff changeset
    17
 * 2 along with this work; if not, write to the Free Software Foundation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    18
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    19
 *
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 2
diff changeset
    20
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 2
diff changeset
    21
 * or visit www.oracle.com if you need additional information or have any
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 2
diff changeset
    22
 * questions.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    23
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    24
90ce3da70b43 Initial load
duke
parents:
diff changeset
    25
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
    26
 * This file is available under and governed by the GNU General Public
90ce3da70b43 Initial load
duke
parents:
diff changeset
    27
 * License version 2 only, as published by the Free Software Foundation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    28
 * However, the following notice accompanied the original version of this
90ce3da70b43 Initial load
duke
parents:
diff changeset
    29
 * file:
90ce3da70b43 Initial load
duke
parents:
diff changeset
    30
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    31
 * Written by Doug Lea with assistance from members of JCP JSR-166
90ce3da70b43 Initial load
duke
parents:
diff changeset
    32
 * Expert Group and released to the public domain, as explained at
9242
ef138d47df58 7034657: Update Creative Commons license URL in legal notices
dl
parents: 5506
diff changeset
    33
 * http://creativecommons.org/publicdomain/zero/1.0/
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    34
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    35
90ce3da70b43 Initial load
duke
parents:
diff changeset
    36
package java.util.concurrent.atomic;
32838
caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes
dl
parents: 25859
diff changeset
    37
15267
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
    38
import java.util.function.IntBinaryOperator;
32838
caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes
dl
parents: 25859
diff changeset
    39
import java.util.function.IntUnaryOperator;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    40
90ce3da70b43 Initial load
duke
parents:
diff changeset
    41
/**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    42
 * An {@code int} value that may be updated atomically.  See the
90ce3da70b43 Initial load
duke
parents:
diff changeset
    43
 * {@link java.util.concurrent.atomic} package specification for
90ce3da70b43 Initial load
duke
parents:
diff changeset
    44
 * description of the properties of atomic variables. An
90ce3da70b43 Initial load
duke
parents:
diff changeset
    45
 * {@code AtomicInteger} is used in applications such as atomically
90ce3da70b43 Initial load
duke
parents:
diff changeset
    46
 * incremented counters, and cannot be used as a replacement for an
90ce3da70b43 Initial load
duke
parents:
diff changeset
    47
 * {@link java.lang.Integer}. However, this class does extend
90ce3da70b43 Initial load
duke
parents:
diff changeset
    48
 * {@code Number} to allow uniform access by tools and utilities that
90ce3da70b43 Initial load
duke
parents:
diff changeset
    49
 * deal with numerically-based classes.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    50
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    51
 * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
    52
 * @author Doug Lea
32838
caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes
dl
parents: 25859
diff changeset
    53
 */
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    54
public class AtomicInteger extends Number implements java.io.Serializable {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    55
    private static final long serialVersionUID = 6214790243416807050L;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    56
33674
566777f73c32 8140606: Update library code to use internal Unsafe
chegar
parents: 32838
diff changeset
    57
    private static final jdk.internal.misc.Unsafe U = jdk.internal.misc.Unsafe.getUnsafe();
32838
caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes
dl
parents: 25859
diff changeset
    58
    private static final long VALUE;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    59
90ce3da70b43 Initial load
duke
parents:
diff changeset
    60
    static {
11134
9ff7640994bf 7117360: Warnings in java.util.concurrent.atomic package
dl
parents: 10067
diff changeset
    61
        try {
32838
caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes
dl
parents: 25859
diff changeset
    62
            VALUE = U.objectFieldOffset
11134
9ff7640994bf 7117360: Warnings in java.util.concurrent.atomic package
dl
parents: 10067
diff changeset
    63
                (AtomicInteger.class.getDeclaredField("value"));
32838
caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes
dl
parents: 25859
diff changeset
    64
        } catch (ReflectiveOperationException e) {
caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes
dl
parents: 25859
diff changeset
    65
            throw new Error(e);
caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes
dl
parents: 25859
diff changeset
    66
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    67
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    68
90ce3da70b43 Initial load
duke
parents:
diff changeset
    69
    private volatile int value;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    70
90ce3da70b43 Initial load
duke
parents:
diff changeset
    71
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    72
     * Creates a new AtomicInteger with the given initial value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    73
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    74
     * @param initialValue the initial value
90ce3da70b43 Initial load
duke
parents:
diff changeset
    75
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    76
    public AtomicInteger(int initialValue) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    77
        value = initialValue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    78
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    79
90ce3da70b43 Initial load
duke
parents:
diff changeset
    80
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    81
     * Creates a new AtomicInteger with initial value {@code 0}.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    82
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    83
    public AtomicInteger() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    84
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    85
90ce3da70b43 Initial load
duke
parents:
diff changeset
    86
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    87
     * Gets the current value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    88
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    89
     * @return the current value
90ce3da70b43 Initial load
duke
parents:
diff changeset
    90
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    91
    public final int get() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    92
        return value;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    93
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    94
90ce3da70b43 Initial load
duke
parents:
diff changeset
    95
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    96
     * Sets to the given value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    97
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    98
     * @param newValue the new value
90ce3da70b43 Initial load
duke
parents:
diff changeset
    99
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   100
    public final void set(int newValue) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   101
        value = newValue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   102
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   103
90ce3da70b43 Initial load
duke
parents:
diff changeset
   104
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   105
     * Eventually sets to the given value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   106
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   107
     * @param newValue the new value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   108
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
   109
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   110
    public final void lazySet(int newValue) {
36936
bfcdf736a998 8152698: Remove obsolete Unsafe.putOrdered{X} methods, usages, runtime and compiler support
shade
parents: 33674
diff changeset
   111
        U.putIntRelease(this, VALUE, newValue);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   112
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   113
90ce3da70b43 Initial load
duke
parents:
diff changeset
   114
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   115
     * Atomically sets to the given value and returns the old value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   116
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   117
     * @param newValue the new value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   118
     * @return the previous value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   119
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   120
    public final int getAndSet(int newValue) {
32838
caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes
dl
parents: 25859
diff changeset
   121
        return U.getAndSetInt(this, VALUE, newValue);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   122
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   123
90ce3da70b43 Initial load
duke
parents:
diff changeset
   124
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   125
     * Atomically sets the value to the given updated value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   126
     * if the current value {@code ==} the expected value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   127
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   128
     * @param expect the expected value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   129
     * @param update the new value
18576
7a5c231327af 8019377: Sync j.u.c locks and atomic from 166 to tl
dl
parents: 16011
diff changeset
   130
     * @return {@code true} if successful. False return indicates that
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   131
     * the actual value was not equal to the expected value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   132
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   133
    public final boolean compareAndSet(int expect, int update) {
32838
caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes
dl
parents: 25859
diff changeset
   134
        return U.compareAndSwapInt(this, VALUE, expect, update);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   135
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   136
90ce3da70b43 Initial load
duke
parents:
diff changeset
   137
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   138
     * Atomically sets the value to the given updated value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   139
     * if the current value {@code ==} the expected value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   140
     *
18576
7a5c231327af 8019377: Sync j.u.c locks and atomic from 166 to tl
dl
parents: 16011
diff changeset
   141
     * <p><a href="package-summary.html#weakCompareAndSet">May fail
7a5c231327af 8019377: Sync j.u.c locks and atomic from 166 to tl
dl
parents: 16011
diff changeset
   142
     * spuriously and does not provide ordering guarantees</a>, so is
7a5c231327af 8019377: Sync j.u.c locks and atomic from 166 to tl
dl
parents: 16011
diff changeset
   143
     * only rarely an appropriate alternative to {@code compareAndSet}.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   144
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   145
     * @param expect the expected value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   146
     * @param update the new value
18576
7a5c231327af 8019377: Sync j.u.c locks and atomic from 166 to tl
dl
parents: 16011
diff changeset
   147
     * @return {@code true} if successful
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   148
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   149
    public final boolean weakCompareAndSet(int expect, int update) {
32838
caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes
dl
parents: 25859
diff changeset
   150
        return U.compareAndSwapInt(this, VALUE, expect, update);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   151
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   152
90ce3da70b43 Initial load
duke
parents:
diff changeset
   153
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   154
     * Atomically increments by one the current value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   155
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   156
     * @return the previous value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   157
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   158
    public final int getAndIncrement() {
32838
caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes
dl
parents: 25859
diff changeset
   159
        return U.getAndAddInt(this, VALUE, 1);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   160
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   161
90ce3da70b43 Initial load
duke
parents:
diff changeset
   162
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   163
     * Atomically decrements by one the current value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   164
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   165
     * @return the previous value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   166
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   167
    public final int getAndDecrement() {
32838
caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes
dl
parents: 25859
diff changeset
   168
        return U.getAndAddInt(this, VALUE, -1);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   169
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   170
90ce3da70b43 Initial load
duke
parents:
diff changeset
   171
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   172
     * Atomically adds the given value to the current value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   173
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   174
     * @param delta the value to add
90ce3da70b43 Initial load
duke
parents:
diff changeset
   175
     * @return the previous value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   176
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   177
    public final int getAndAdd(int delta) {
32838
caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes
dl
parents: 25859
diff changeset
   178
        return U.getAndAddInt(this, VALUE, delta);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   179
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   180
90ce3da70b43 Initial load
duke
parents:
diff changeset
   181
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   182
     * Atomically increments by one the current value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   183
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   184
     * @return the updated value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   185
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   186
    public final int incrementAndGet() {
32838
caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes
dl
parents: 25859
diff changeset
   187
        return U.getAndAddInt(this, VALUE, 1) + 1;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   188
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   189
90ce3da70b43 Initial load
duke
parents:
diff changeset
   190
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   191
     * Atomically decrements by one the current value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   192
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   193
     * @return the updated value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   194
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   195
    public final int decrementAndGet() {
32838
caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes
dl
parents: 25859
diff changeset
   196
        return U.getAndAddInt(this, VALUE, -1) - 1;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   197
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   198
90ce3da70b43 Initial load
duke
parents:
diff changeset
   199
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   200
     * Atomically adds the given value to the current value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   201
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   202
     * @param delta the value to add
90ce3da70b43 Initial load
duke
parents:
diff changeset
   203
     * @return the updated value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   204
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   205
    public final int addAndGet(int delta) {
32838
caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes
dl
parents: 25859
diff changeset
   206
        return U.getAndAddInt(this, VALUE, delta) + delta;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   207
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   208
90ce3da70b43 Initial load
duke
parents:
diff changeset
   209
    /**
15267
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   210
     * Atomically updates the current value with the results of
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   211
     * applying the given function, returning the previous value. The
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   212
     * function should be side-effect-free, since it may be re-applied
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   213
     * when attempted updates fail due to contention among threads.
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   214
     *
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   215
     * @param updateFunction a side-effect-free function
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   216
     * @return the previous value
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   217
     * @since 1.8
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   218
     */
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   219
    public final int getAndUpdate(IntUnaryOperator updateFunction) {
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   220
        int prev, next;
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   221
        do {
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   222
            prev = get();
16011
890a7ed97f6c 8004561: Additional functional interfaces, extension methods and name changes
mduigou
parents: 15267
diff changeset
   223
            next = updateFunction.applyAsInt(prev);
15267
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   224
        } while (!compareAndSet(prev, next));
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   225
        return prev;
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   226
    }
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   227
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   228
    /**
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   229
     * Atomically updates the current value with the results of
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   230
     * applying the given function, returning the updated value. The
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   231
     * function should be side-effect-free, since it may be re-applied
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   232
     * when attempted updates fail due to contention among threads.
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   233
     *
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   234
     * @param updateFunction a side-effect-free function
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   235
     * @return the updated value
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   236
     * @since 1.8
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   237
     */
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   238
    public final int updateAndGet(IntUnaryOperator updateFunction) {
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   239
        int prev, next;
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   240
        do {
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   241
            prev = get();
16011
890a7ed97f6c 8004561: Additional functional interfaces, extension methods and name changes
mduigou
parents: 15267
diff changeset
   242
            next = updateFunction.applyAsInt(prev);
15267
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   243
        } while (!compareAndSet(prev, next));
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   244
        return next;
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   245
    }
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   246
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   247
    /**
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   248
     * Atomically updates the current value with the results of
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   249
     * applying the given function to the current and given values,
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   250
     * returning the previous value. The function should be
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   251
     * side-effect-free, since it may be re-applied when attempted
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   252
     * updates fail due to contention among threads.  The function
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   253
     * is applied with the current value as its first argument,
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   254
     * and the given update as the second argument.
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   255
     *
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   256
     * @param x the update value
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   257
     * @param accumulatorFunction a side-effect-free function of two arguments
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   258
     * @return the previous value
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   259
     * @since 1.8
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   260
     */
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   261
    public final int getAndAccumulate(int x,
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   262
                                      IntBinaryOperator accumulatorFunction) {
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   263
        int prev, next;
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   264
        do {
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   265
            prev = get();
16011
890a7ed97f6c 8004561: Additional functional interfaces, extension methods and name changes
mduigou
parents: 15267
diff changeset
   266
            next = accumulatorFunction.applyAsInt(prev, x);
15267
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   267
        } while (!compareAndSet(prev, next));
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   268
        return prev;
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   269
    }
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   270
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   271
    /**
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   272
     * Atomically updates the current value with the results of
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   273
     * applying the given function to the current and given values,
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   274
     * returning the updated value. The function should be
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   275
     * side-effect-free, since it may be re-applied when attempted
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   276
     * updates fail due to contention among threads.  The function
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   277
     * is applied with the current value as its first argument,
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   278
     * and the given update as the second argument.
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   279
     *
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   280
     * @param x the update value
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   281
     * @param accumulatorFunction a side-effect-free function of two arguments
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   282
     * @return the updated value
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   283
     * @since 1.8
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   284
     */
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   285
    public final int accumulateAndGet(int x,
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   286
                                      IntBinaryOperator accumulatorFunction) {
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   287
        int prev, next;
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   288
        do {
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   289
            prev = get();
16011
890a7ed97f6c 8004561: Additional functional interfaces, extension methods and name changes
mduigou
parents: 15267
diff changeset
   290
            next = accumulatorFunction.applyAsInt(prev, x);
15267
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   291
        } while (!compareAndSet(prev, next));
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   292
        return next;
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   293
    }
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   294
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes
dl
parents: 15020
diff changeset
   295
    /**
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   296
     * Returns the String representation of the current value.
15020
50394fa17c1b 8006007: j.u.c.atomic classes should use intrinsic getAndXXX provided by 7023898
chegar
parents: 14325
diff changeset
   297
     * @return the String representation of the current value
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   298
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   299
    public String toString() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   300
        return Integer.toString(get());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   301
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   302
10067
1263ecd22db6 6253144: Long narrowing conversion should describe the algorithm used and implied "risks"
darcy
parents: 9242
diff changeset
   303
    /**
11134
9ff7640994bf 7117360: Warnings in java.util.concurrent.atomic package
dl
parents: 10067
diff changeset
   304
     * Returns the value of this {@code AtomicInteger} as an {@code int}.
32838
caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes
dl
parents: 25859
diff changeset
   305
     * Equivalent to {@link #get()}.
10067
1263ecd22db6 6253144: Long narrowing conversion should describe the algorithm used and implied "risks"
darcy
parents: 9242
diff changeset
   306
     */
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   307
    public int intValue() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   308
        return get();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   309
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   310
10067
1263ecd22db6 6253144: Long narrowing conversion should describe the algorithm used and implied "risks"
darcy
parents: 9242
diff changeset
   311
    /**
1263ecd22db6 6253144: Long narrowing conversion should describe the algorithm used and implied "risks"
darcy
parents: 9242
diff changeset
   312
     * Returns the value of this {@code AtomicInteger} as a {@code long}
1263ecd22db6 6253144: Long narrowing conversion should describe the algorithm used and implied "risks"
darcy
parents: 9242
diff changeset
   313
     * after a widening primitive conversion.
1263ecd22db6 6253144: Long narrowing conversion should describe the algorithm used and implied "risks"
darcy
parents: 9242
diff changeset
   314
     * @jls 5.1.2 Widening Primitive Conversions
1263ecd22db6 6253144: Long narrowing conversion should describe the algorithm used and implied "risks"
darcy
parents: 9242
diff changeset
   315
     */
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   316
    public long longValue() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   317
        return (long)get();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   318
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   319
10067
1263ecd22db6 6253144: Long narrowing conversion should describe the algorithm used and implied "risks"
darcy
parents: 9242
diff changeset
   320
    /**
1263ecd22db6 6253144: Long narrowing conversion should describe the algorithm used and implied "risks"
darcy
parents: 9242
diff changeset
   321
     * Returns the value of this {@code AtomicInteger} as a {@code float}
1263ecd22db6 6253144: Long narrowing conversion should describe the algorithm used and implied "risks"
darcy
parents: 9242
diff changeset
   322
     * after a widening primitive conversion.
1263ecd22db6 6253144: Long narrowing conversion should describe the algorithm used and implied "risks"
darcy
parents: 9242
diff changeset
   323
     * @jls 5.1.2 Widening Primitive Conversions
1263ecd22db6 6253144: Long narrowing conversion should describe the algorithm used and implied "risks"
darcy
parents: 9242
diff changeset
   324
     */
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   325
    public float floatValue() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   326
        return (float)get();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   327
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   328
10067
1263ecd22db6 6253144: Long narrowing conversion should describe the algorithm used and implied "risks"
darcy
parents: 9242
diff changeset
   329
    /**
1263ecd22db6 6253144: Long narrowing conversion should describe the algorithm used and implied "risks"
darcy
parents: 9242
diff changeset
   330
     * Returns the value of this {@code AtomicInteger} as a {@code double}
1263ecd22db6 6253144: Long narrowing conversion should describe the algorithm used and implied "risks"
darcy
parents: 9242
diff changeset
   331
     * after a widening primitive conversion.
1263ecd22db6 6253144: Long narrowing conversion should describe the algorithm used and implied "risks"
darcy
parents: 9242
diff changeset
   332
     * @jls 5.1.2 Widening Primitive Conversions
1263ecd22db6 6253144: Long narrowing conversion should describe the algorithm used and implied "risks"
darcy
parents: 9242
diff changeset
   333
     */
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   334
    public double doubleValue() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   335
        return (double)get();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   336
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   337
90ce3da70b43 Initial load
duke
parents:
diff changeset
   338
}