Robust/src/ClassLibrary/MGC/gnu/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 Object/*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(Object/*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 Object/*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(Object/*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(Object/*V*/ newValue) {
  73         synchronized (this) {
  74             value = newValue;
  75         }
  76         //unsafe.putOrderedObject(this, valueOffset, newValue);
  77     }
  78
  79     /**
  80      * Atomically sets the value to the given updated value
  81      * if the current value <tt>==</tt> the expected value.
  82      * @param expect the expected value
  83      * @param update the new value
  84      * @return true if successful. False return indicates that
  85      * the actual value was not equal to the expected value.
  86      */
  87     public final boolean compareAndSet(Object/*V*/ expect, Object/*V*/ update) {
  88         synchronized (this) {
  89             if(expect == value) {
  90                 value = update;
  91                 return true;
  92             } else {
  93                 return false;
  94             }
  95         }
  96         //return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
  97     }
  98
  99     /**
 100      * Atomically sets the value to the given updated value
 101      * if the current value <tt>==</tt> the expected value.
 102      * May fail spuriously and does not provide ordering guarantees,
 103      * so is only rarely an appropriate alternative to <tt>compareAndSet</tt>.
 104      *
 105      * @param expect the expected value
 106      * @param update the new value
 107      * @return true if successful.
 108      */
 109     public final boolean weakCompareAndSet(Object/*V*/ expect, Object/*V*/ update) {
 110         synchronized (this) {
 111             if(expect == value) {
 112                 value = update;
 113                 return true;
 114             } else {
 115                 return false;
 116             }
 117         }
 118         //return unsafe.compareAndSwapObject(this, valueOffset, expect, update);\
 119     }
 120
 121     /**
 122      * Atomically sets to the given value and returns the old value.
 123      *
 124      * @param newValue the new value
 125      * @return the previous value
 126      */
 127     public final Object/*V*/ getAndSet(Object/*V*/ newValue) {
 128         while (true) {
 129             Object/*V*/ x = get();
 130             if (compareAndSet(x, newValue))
 131                 return x;
 132         }
 133     }
 134
 135     /**
 136      * Returns the String representation of the current value.
 137      * @return the String representation of the current value.
 138      */
 139     /*public String toString() {
 140         return String.valueOf(get());
 141     }*/
 142
 143 }