GNU Classpath (0.98) | |
Frames | No Frames |
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: }
GNU Classpath (0.98) |