Robust/src/ClassLibrary/MGC/gnu/AtomicBoolean.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  * A <tt>boolean</tt> value that may be updated atomically. See the
  12  * {@link java.util.concurrent.atomic} package specification for
  13  * description of the properties of atomic variables. An
  14  * <tt>AtomicBoolean</tt> is used in applications such as atomically
  15  * updated flags, and cannot be used as a replacement for a
  16  * {@link java.lang.Boolean}.
  17  *
  18  * @since 1.5
  19  * @author Doug Lea
  20  */
  21 public class AtomicBoolean implements java.io.Serializable {
  22     private static final long serialVersionUID = 4654671469794556979L;
  23     // setup to use Unsafe.compareAndSwapInt for updates
  24     /*private static final Unsafe unsafe = Unsafe.getUnsafe();
  25     private static final long valueOffset;
  26
  27     static {
  28       try {
  29         valueOffset = unsafe.objectFieldOffset
  30             (AtomicBoolean.class.getDeclaredField("value"));
  31       } catch (Exception ex) { throw new Error(ex); }
  32     }*/
  33
  34     private volatile int value;
  35
  36     /**
  37      * Creates a new <tt>AtomicBoolean</tt> with the given initial value.
  38      *
  39      * @param initialValue the initial value
  40      */
  41     public AtomicBoolean(boolean initialValue) {
  42         value = initialValue ? 1 : 0;
  43     }
  44
  45     /**
  46      * Creates a new <tt>AtomicBoolean</tt> with initial value <tt>false</tt>.
  47      */
  48     public AtomicBoolean() {
  49     }
  50
  51     /**
  52      * Returns the current value.
  53      *
  54      * @return the current value
  55      */
  56     public final boolean get() {
  57         return value != 0;
  58     }
  59
  60     /**
  61      * Atomically sets the value to the given updated value
  62      * if the current value <tt>==</tt> the expected value.
  63      *
  64      * @param expect the expected value
  65      * @param update the new value
  66      * @return true if successful. False return indicates that
  67      * the actual value was not equal to the expected value.
  68      */
  69     public final boolean compareAndSet(boolean expect, boolean update) {
  70         int e = expect ? 1 : 0;
  71         int u = update ? 1 : 0;
  72         synchronized (this) {
  73             if(e == value) {
  74                 value = u;
  75                 return true;
  76             } else {
  77                 return false;
  78             }
  79         }
  80         //return unsafe.compareAndSwapInt(this, valueOffset, e, u);
  81     }
  82
  83     /**
  84      * Atomically sets the value to the given updated value
  85      * if the current value <tt>==</tt> the expected value.
  86      * May fail spuriously and does not provide ordering guarantees,
  87      * so is only rarely an appropriate alternative to <tt>compareAndSet</tt>.
  88      *
  89      * @param expect the expected value
  90      * @param update the new value
  91      * @return true if successful.
  92      */
  93     public boolean weakCompareAndSet(boolean expect, boolean update) {
  94         int e = expect ? 1 : 0;
  95         int u = update ? 1 : 0;
  96         synchronized (this) {
  97             if(e == value) {
  98                 value = u;
  99                 return true;
 100             } else {
 101                 return false;
 102             }
 103         }
 104         //return unsafe.compareAndSwapInt(this, valueOffset, e, u);*/
 105     }
 106
 107     /**
 108      * Unconditionally sets to the given value.
 109      *
 110      * @param newValue the new value
 111      */
 112     public final void set(boolean newValue) {
 113         value = newValue ? 1 : 0;
 114     }
 115
 116     /**
 117      * Eventually sets to the given value.
 118      *
 119      * @param newValue the new value
 120      * @since 1.6
 121      */
 122     public final void lazySet(boolean newValue) {
 123         int v = newValue ? 1 : 0;
 124         synchronized (this) {
 125             value = v;
 126         }
 127         //unsafe.putOrderedInt(this, valueOffset, v);
 128     }
 129
 130     /**
 131      * Atomically sets to the given value and returns the previous value.
 132      *
 133      * @param newValue the new value
 134      * @return the previous value
 135      */
 136     public final boolean getAndSet(boolean newValue) {
 137         for (;;) {
 138             boolean current = get();
 139             if (compareAndSet(current, newValue))
 140                 return current;
 141         }
 142     }
 143
 144     /**
 145      * Returns the String representation of the current value.
 146      * @return the String representation of the current value.
 147      */
 148     /*public String toString() {
 149         return Boolean.toString(get());
 150     }*/
 151
 152 }