lib/classpath/external/jsr166/java/util/concurrent/atomic/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         return unsafe.compareAndSwapInt(this, valueOffset, e, u);
  73     }
  74
  75     /**
  76      * Atomically sets the value to the given updated value
  77      * if the current value <tt>==</tt> the expected value.
  78      * May fail spuriously and does not provide ordering guarantees,
  79      * so is only rarely an appropriate alternative to <tt>compareAndSet</tt>.
  80      *
  81      * @param expect the expected value
  82      * @param update the new value
  83      * @return true if successful.
  84      */
  85     public boolean weakCompareAndSet(boolean expect, boolean update) {
  86         int e = expect ? 1 : 0;
  87         int u = update ? 1 : 0;
  88         return unsafe.compareAndSwapInt(this, valueOffset, e, u);
  89     }
  90
  91     /**
  92      * Unconditionally sets to the given value.
  93      *
  94      * @param newValue the new value
  95      */
  96     public final void set(boolean newValue) {
  97         value = newValue ? 1 : 0;
  98     }
  99
 100     /**
 101      * Eventually sets to the given value.
 102      *
 103      * @param newValue the new value
 104      * @since 1.6
 105      */
 106     public final void lazySet(boolean newValue) {
 107         int v = newValue ? 1 : 0;
 108         unsafe.putOrderedInt(this, valueOffset, v);
 109     }
 110
 111     /**
 112      * Atomically sets to the given value and returns the previous value.
 113      *
 114      * @param newValue the new value
 115      * @return the previous value
 116      */
 117     public final boolean getAndSet(boolean newValue) {
 118         for (;;) {
 119             boolean current = get();
 120             if (compareAndSet(current, newValue))
 121                 return current;
 122         }
 123     }
 124
 125     /**
 126      * Returns the String representation of the current value.
 127      * @return the String representation of the current value.
 128      */
 129     public String toString() {
 130         return Boolean.toString(get());
 131     }
 132
 133 }