lib/classpath/external/jsr166/java/util/concurrent/atomic/AtomicReference.java

   1 /*
   2  * Written by Doug Lea with assistance from members of JCP JSR-166
   3  * Expert Group and released to the public domain, as explained at
   4  * http://creativecommons.org/licenses/publicdomain
   5  */
   6
   7 package java.util.concurrent.atomic;
   8 import sun.misc.Unsafe;
   9
  10 /**
  11  * An object reference that may be updated atomically. See the {@link
  12  * java.util.concurrent.atomic} package specification for description
  13  * of the properties of atomic variables.
  14  * @since 1.5
  15  * @author Doug Lea
  16  * @param <V> The type of object referred to by this reference
  17  */
  18 public class AtomicReference<V>  implements java.io.Serializable {
  19     private static final long serialVersionUID = -1848883965231344442L;
  20
  21     private static final Unsafe unsafe = Unsafe.getUnsafe();
  22     private static final long valueOffset;
  23
  24     static {
  25       try {
  26         valueOffset = unsafe.objectFieldOffset
  27             (AtomicReference.class.getDeclaredField("value"));
  28       } catch (Exception ex) { throw new Error(ex); }
  29     }
  30
  31     private volatile V value;
  32
  33     /**
  34      * Creates a new AtomicReference with the given initial value.
  35      *
  36      * @param initialValue the initial value
  37      */
  38     public AtomicReference(V initialValue) {
  39         value = initialValue;
  40     }
  41
  42     /**
  43      * Creates a new AtomicReference with null initial value.
  44      */
  45     public AtomicReference() {
  46     }
  47
  48     /**
  49      * Gets the current value.
  50      *
  51      * @return the current value
  52      */
  53     public final V get() {
  54         return value;
  55     }
  56
  57     /**
  58      * Sets to the given value.
  59      *
  60      * @param newValue the new value
  61      */
  62     public final void set(V newValue) {
  63         value = newValue;
  64     }
  65
  66     /**
  67      * Eventually sets to the given value.
  68      *
  69      * @param newValue the new value
  70      * @since 1.6
  71      */
  72     public final void lazySet(V newValue) {
  73         unsafe.putOrderedObject(this, valueOffset, newValue);
  74     }
  75
  76     /**
  77      * Atomically sets the value to the given updated value
  78      * if the current value <tt>==</tt> the expected value.
  79      * @param expect the expected value
  80      * @param update the new value
  81      * @return true if successful. False return indicates that
  82      * the actual value was not equal to the expected value.
  83      */
  84     public final boolean compareAndSet(V expect, V update) {
  85         return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
  86     }
  87
  88     /**
  89      * Atomically sets the value to the given updated value
  90      * if the current value <tt>==</tt> the expected value.
  91      * May fail spuriously and does not provide ordering guarantees,
  92      * so is only rarely an appropriate alternative to <tt>compareAndSet</tt>.
  93      *
  94      * @param expect the expected value
  95      * @param update the new value
  96      * @return true if successful.
  97      */
  98     public final boolean weakCompareAndSet(V expect, V update) {
  99         return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
 100     }
 101
 102     /**
 103      * Atomically sets to the given value and returns the old value.
 104      *
 105      * @param newValue the new value
 106      * @return the previous value
 107      */
 108     public final V getAndSet(V newValue) {
 109         while (true) {
 110             V x = get();
 111             if (compareAndSet(x, newValue))
 112                 return x;
 113         }
 114     }
 115
 116     /**
 117      * Returns the String representation of the current value.
 118      * @return the String representation of the current value.
 119      */
 120     public String toString() {
 121         return String.valueOf(get());
 122     }
 123
 124 }