沉淀再出发：java中的CAS和ABA问题整理

  1 /*
  2  * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
  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  * 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.IntUnaryOperator;
 38 import java.util.function.IntBinaryOperator;
 39 import sun.misc.Unsafe;
 40 
 41 /**
 42  * An {@code int} 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 AtomicInteger} is used in applications such as atomically
 46  * incremented counters, and cannot be used as a replacement for an
 47  * {@link java.lang.Integer}. 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 AtomicInteger extends Number implements java.io.Serializable {
 55     private static final long serialVersionUID = 6214790243416807050L;
 56 
 57     // setup to use Unsafe.compareAndSwapInt for updates
 58     private static final Unsafe unsafe = Unsafe.getUnsafe();
 59     private static final long valueOffset;
 60 
 61     static {
 62         try {
 63             valueOffset = unsafe.objectFieldOffset
 64                 (AtomicInteger.class.getDeclaredField("value"));
 65         } catch (Exception ex) { throw new Error(ex); }
 66     }
 67 
 68     private volatile int value;
 69 
 70     /**
 71      * Creates a new AtomicInteger with the given initial value.
 72      *
 73      * @param initialValue the initial value
 74      */
 75     public AtomicInteger(int initialValue) {
 76         value = initialValue;
 77     }
 78 
 79     /**
 80      * Creates a new AtomicInteger with initial value {@code 0}.
 81      */
 82     public AtomicInteger() {
 83     }
 84 
 85     /**
 86      * Gets the current value.
 87      *
 88      * @return the current value
 89      */
 90     public final int get() {
 91         return value;
 92     }
 93 
 94     /**
 95      * Sets to the given value.
 96      *
 97      * @param newValue the new value
 98      */
 99     public final void set(int newValue) {
100         value = newValue;
101     }
102 
103     /**
104      * Eventually sets to the given value.
105      *
106      * @param newValue the new value
107      * @since 1.6
108      */
109     public final void lazySet(int newValue) {
110         unsafe.putOrderedInt(this, valueOffset, newValue);
111     }
112 
113     /**
114      * Atomically sets to the given value and returns the old value.
115      *
116      * @param newValue the new value
117      * @return the previous value
118      */
119     public final int getAndSet(int newValue) {
120         return unsafe.getAndSetInt(this, valueOffset, newValue);
121     }
122 
123     /**
124      * Atomically sets the value to the given updated value
125      * if the current value {@code ==} the expected value.
126      *
127      * @param expect the expected value
128      * @param update the new value
129      * @return {@code true} if successful. False return indicates that
130      * the actual value was not equal to the expected value.
131      */
132     public final boolean compareAndSet(int expect, int update) {
133         return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
134     }
135 
136     /**
137      * Atomically sets the value to the given updated value
138      * if the current value {@code ==} the expected value.
139      *
140      * <p><a href="package-summary.html#weakCompareAndSet">May fail
141      * spuriously and does not provide ordering guarantees</a>, so is
142      * only rarely an appropriate alternative to {@code compareAndSet}.
143      *
144      * @param expect the expected value
145      * @param update the new value
146      * @return {@code true} if successful
147      */
148     public final boolean weakCompareAndSet(int expect, int update) {
149         return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
150     }
151 
152     /**
153      * Atomically increments by one the current value.
154      *
155      * @return the previous value
156      */
157     public final int getAndIncrement() {
158         return unsafe.getAndAddInt(this, valueOffset, 1);
159     }
160 
161     /**
162      * Atomically decrements by one the current value.
163      *
164      * @return the previous value
165      */
166     public final int getAndDecrement() {
167         return unsafe.getAndAddInt(this, valueOffset, -1);
168     }
169 
170     /**
171      * Atomically adds the given value to the current value.
172      *
173      * @param delta the value to add
174      * @return the previous value
175      */
176     public final int getAndAdd(int delta) {
177         return unsafe.getAndAddInt(this, valueOffset, delta);
178     }
179 
180     /**
181      * Atomically increments by one the current value.
182      *
183      * @return the updated value
184      */
185     public final int incrementAndGet() {
186         return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
187     }
188 
189     /**
190      * Atomically decrements by one the current value.
191      *
192      * @return the updated value
193      */
194     public final int decrementAndGet() {
195         return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
196     }
197 
198     /**
199      * Atomically adds the given value to the current value.
200      *
201      * @param delta the value to add
202      * @return the updated value
203      */
204     public final int addAndGet(int delta) {
205         return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
206     }
207 
208     /**
209      * Atomically updates the current value with the results of
210      * applying the given function, returning the previous value. The
211      * function should be side-effect-free, since it may be re-applied
212      * when attempted updates fail due to contention among threads.
213      *
214      * @param updateFunction a side-effect-free function
215      * @return the previous value
216      * @since 1.8
217      */
218     public final int getAndUpdate(IntUnaryOperator updateFunction) {
219         int prev, next;
220         do {
221             prev = get();
222             next = updateFunction.applyAsInt(prev);
223         } while (!compareAndSet(prev, next));
224         return prev;
225     }
226 
227     /**
228      * Atomically updates the current value with the results of
229      * applying the given function, returning the updated value. The
230      * function should be side-effect-free, since it may be re-applied
231      * when attempted updates fail due to contention among threads.
232      *
233      * @param updateFunction a side-effect-free function
234      * @return the updated value
235      * @since 1.8
236      */
237     public final int updateAndGet(IntUnaryOperator updateFunction) {
238         int prev, next;
239         do {
240             prev = get();
241             next = updateFunction.applyAsInt(prev);
242         } while (!compareAndSet(prev, next));
243         return next;
244     }
245 
246     /**
247      * Atomically updates the current value with the results of
248      * applying the given function to the current and given values,
249      * returning the previous value. The function should be
250      * side-effect-free, since it may be re-applied when attempted
251      * updates fail due to contention among threads.  The function
252      * is applied with the current value as its first argument,
253      * and the given update as the second argument.
254      *
255      * @param x the update value
256      * @param accumulatorFunction a side-effect-free function of two arguments
257      * @return the previous value
258      * @since 1.8
259      */
260     public final int getAndAccumulate(int x,
261                                       IntBinaryOperator accumulatorFunction) {
262         int prev, next;
263         do {
264             prev = get();
265             next = accumulatorFunction.applyAsInt(prev, x);
266         } while (!compareAndSet(prev, next));
267         return prev;
268     }
269 
270     /**
271      * Atomically updates the current value with the results of
272      * applying the given function to the current and given values,
273      * returning the updated value. The function should be
274      * side-effect-free, since it may be re-applied when attempted
275      * updates fail due to contention among threads.  The function
276      * is applied with the current value as its first argument,
277      * and the given update as the second argument.
278      *
279      * @param x the update value
280      * @param accumulatorFunction a side-effect-free function of two arguments
281      * @return the updated value
282      * @since 1.8
283      */
284     public final int accumulateAndGet(int x,
285                                       IntBinaryOperator accumulatorFunction) {
286         int prev, next;
287         do {
288             prev = get();
289             next = accumulatorFunction.applyAsInt(prev, x);
290         } while (!compareAndSet(prev, next));
291         return next;
292     }
293 
294     /**
295      * Returns the String representation of the current value.
296      * @return the String representation of the current value
297      */
298     public String toString() {
299         return Integer.toString(get());
300     }
301 
302     /**
303      * Returns the value of this {@code AtomicInteger} as an {@code int}.
304      */
305     public int intValue() {
306         return get();
307     }
308 
309     /**
310      * Returns the value of this {@code AtomicInteger} as a {@code long}
311      * after a widening primitive conversion.
312      * @jls 5.1.2 Widening Primitive Conversions
313      */
314     public long longValue() {
315         return (long)get();
316     }
317 
318     /**
319      * Returns the value of this {@code AtomicInteger} as a {@code float}
320      * after a widening primitive conversion.
321      * @jls 5.1.2 Widening Primitive Conversions
322      */
323     public float floatValue() {
324         return (float)get();
325     }
326 
327     /**
328      * Returns the value of this {@code AtomicInteger} as a {@code double}
329      * after a widening primitive conversion.
330      * @jls 5.1.2 Widening Primitive Conversions
331      */
332     public double doubleValue() {
333         return (double)get();
334     }
335 
336 }

/*
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

/*
 *
 *
 *
 *
 *
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */

package java.util.concurrent.atomic;

/**
 * An {@code AtomicStampedReference} maintains an object reference
 * along with an integer "stamp", that can be updated atomically.
 *
 * <p>Implementation note: This implementation maintains stamped
 * references by creating internal objects representing "boxed"
 * [reference, integer] pairs.
 *
 * @since 1.5
 * @author Doug Lea
 * @param <V> The type of object referred to by this reference
 */
public class AtomicStampedReference<V> {

    private static class Pair<T> {
        final T reference;
        final int stamp;
        private Pair(T reference, int stamp) {
            this.reference = reference;
            this.stamp = stamp;
        }
        static <T> Pair<T> of(T reference, int stamp) {
            return new Pair<T>(reference, stamp);
        }
    }

    private volatile Pair<V> pair;

    /**
     * Creates a new {@code AtomicStampedReference} with the given
     * initial values.
     *
     * @param initialRef the initial reference
     * @param initialStamp the initial stamp
     */
    public AtomicStampedReference(V initialRef, int initialStamp) {
        pair = Pair.of(initialRef, initialStamp);
    }

    /**
     * Returns the current value of the reference.
     *
     * @return the current value of the reference
     */
    public V getReference() {
        return pair.reference;
    }

    /**
     * Returns the current value of the stamp.
     *
     * @return the current value of the stamp
     */
    public int getStamp() {
        return pair.stamp;
    }

    /**
     * Returns the current values of both the reference and the stamp.
     * Typical usage is {@code int[1] holder; ref = v.get(holder); }.
     *
     * @param stampHolder an array of size of at least one.  On return,
     * {@code stampholder[0]} will hold the value of the stamp.
     * @return the current value of the reference
     */
    public V get(int[] stampHolder) {
        Pair<V> pair = this.pair;
        stampHolder[0] = pair.stamp;
        return pair.reference;
    }

    /**
     * Atomically sets the value of both the reference and stamp
     * to the given update values if the
     * current reference is {@code ==} to the expected reference
     * and the current stamp is equal to the expected stamp.
     *
     * <p><a href="package-summary.html#weakCompareAndSet">May fail
     * spuriously and does not provide ordering guarantees</a>, so is
     * only rarely an appropriate alternative to {@code compareAndSet}.
     *
     * @param expectedReference the expected value of the reference
     * @param newReference the new value for the reference
     * @param expectedStamp the expected value of the stamp
     * @param newStamp the new value for the stamp
     * @return {@code true} if successful
     */
    public boolean weakCompareAndSet(V   expectedReference,
                                     V   newReference,
                                     int expectedStamp,
                                     int newStamp) {
        return compareAndSet(expectedReference, newReference,
                             expectedStamp, newStamp);
    }

    /**
     * Atomically sets the value of both the reference and stamp
     * to the given update values if the
     * current reference is {@code ==} to the expected reference
     * and the current stamp is equal to the expected stamp.
     *
     * @param expectedReference the expected value of the reference
     * @param newReference the new value for the reference
     * @param expectedStamp the expected value of the stamp
     * @param newStamp the new value for the stamp
     * @return {@code true} if successful
     */
    public boolean compareAndSet(V   expectedReference,
                                 V   newReference,
                                 int expectedStamp,
                                 int newStamp) {
        Pair<V> current = pair;
        return
            expectedReference == current.reference &&
            expectedStamp == current.stamp &&
            ((newReference == current.reference &&
              newStamp == current.stamp) ||
             casPair(current, Pair.of(newReference, newStamp)));
    }

    /**
     * Unconditionally sets the value of both the reference and stamp.
     *
     * @param newReference the new value for the reference
     * @param newStamp the new value for the stamp
     */
    public void set(V newReference, int newStamp) {
        Pair<V> current = pair;
        if (newReference != current.reference || newStamp != current.stamp)
            this.pair = Pair.of(newReference, newStamp);
    }

    /**
     * Atomically sets the value of the stamp to the given update value
     * if the current reference is {@code ==} to the expected
     * reference.  Any given invocation of this operation may fail
     * (return {@code false}) spuriously, but repeated invocation
     * when the current value holds the expected value and no other
     * thread is also attempting to set the value will eventually
     * succeed.
     *
     * @param expectedReference the expected value of the reference
     * @param newStamp the new value for the stamp
     * @return {@code true} if successful
     */
    public boolean attemptStamp(V expectedReference, int newStamp) {
        Pair<V> current = pair;
        return
            expectedReference == current.reference &&
            (newStamp == current.stamp ||
             casPair(current, Pair.of(expectedReference, newStamp)));
    }

    // Unsafe mechanics

    private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
    private static final long pairOffset =
        objectFieldOffset(UNSAFE, "pair", AtomicStampedReference.class);

    private boolean casPair(Pair<V> cmp, Pair<V> val) {
        return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
    }

    static long objectFieldOffset(sun.misc.Unsafe UNSAFE,
                                  String field, Class<?> klazz) {
        try {
            return UNSAFE.objectFieldOffset(klazz.getDeclaredField(field));
        } catch (NoSuchFieldException e) {
            // Convert Exception to corresponding Error
            NoSuchFieldError error = new NoSuchFieldError(field);
            error.initCause(e);
            throw error;
        }
    }
}