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