jdk1.6类 java.util.concurrent.atomic.AtomicBoolean

• java.util.concurrent.atomic.AtomicBoolean

java.util.concurrent.atomic.AtomicBoolean

1. public AtomicBoolean(boolean initialValue)
2. public AtomicBoolean()
3. public final boolean get()
4. public final boolean compareAndSet(boolean expect, boolean update)
5. public boolean weakCompareAndSet(boolean expect, boolean update)
6. public final void set(boolean newValue)
7. public final void lazySet(boolean newValue)
8. public final boolean getAndSet(boolean newValue)
9. public String toString()

/*
 * %W% %E%
 *
 * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package java.util.concurrent.atomic;
import sun.misc.Unsafe;

/**
 * A {@code boolean} value that may be updated atomically. See the
 * {@link java.util.concurrent.atomic} package specification for
 * description of the properties of atomic variables. An
 * {@code AtomicBoolean} is used in applications such as atomically
 * updated flags, and cannot be used as a replacement for a
 * {@link java.lang.Boolean}.
 *
 * @since 1.5
 * @author Doug Lea
 */
/**
 * 可以用原子方式更新的 boolean 值。有关原子变量属性的描述，请参阅 
 * java.util.concurrent.atomic 包规范。AtomicBoolean 可用在应用程序中
 * （如以原子方式更新的标志），但不能用于替换 Boolean。
 */
public class AtomicBoolean implements java.io.Serializable {
    private static final long serialVersionUID = 4654671469794556979L;
    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
      try {
        valueOffset = unsafe.objectFieldOffset
            (AtomicBoolean.class.getDeclaredField("value"));
      } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;

    /**
     * Creates a new {@code AtomicBoolean} with the given initial value.
     *
     * @param initialValue the initial value
     */
    /**
     * 使用给定的初始值创建新的 AtomicBoolean。
     * @param  initialValue [初始值]
     * @return              
     */
    public AtomicBoolean(boolean initialValue) {
        value = initialValue ? 1 : 0;
    }

    /**
     * Creates a new {@code AtomicBoolean} with initial value {@code false}.
     */
    /**
     * 使用初始值 false 创建新的 AtomicBoolean
     */
    public AtomicBoolean() {
    }

    /**
     * Returns the current value.
     *
     * @return the current value
     */
    /**
     * 返回当前值。
     * @return [当前值]
     */
    public final boolean get() {
        return value != 0;
    }

    /**
     * Atomically sets the value to the given updated value
     * if the current value {@code ==} the expected value.
     *
     * @param expect the expected value
     * @param update the new value
     * @return true if successful. False return indicates that
     * the actual value was not equal to the expected value.
     */
    /**
     * 如果当前值 == 预期值，则以原子方式将该值设置为给定的更新值。
     * @param  expect 预期值
     * @param  update 新值
     * @return        如果成功，则返回 true。返回 False 指示实际值与预期值不相等。
     */
    public final boolean compareAndSet(boolean expect, boolean update) {
        int e = expect ? 1 : 0;
        int u = update ? 1 : 0;
        return unsafe.compareAndSwapInt(this, valueOffset, e, u);
    }

    /**
     * Atomically sets the value to the given updated value
     * if the current value {@code ==} the expected value.
     *
     * <p>May <a href="package-summary.html#Spurious">fail spuriously</a>
     * and does not provide ordering guarantees, so is only rarely an
     * appropriate alternative to {@code compareAndSet}.
     *
     * @param expect the expected value
     * @param update the new value
     * @return true if successful.
     */
    /**
     * 如果当前值 == 预期值，则以原子方式将该值设置为给定的更新值。
     * 可能意外失败并且不提供排序保证，因此几乎只是 compareAndSet 的适当替代方法。
     * @param  expect [预期值]
     * @param  update [新值]
     * @return        如果成功，则返回 true。
     */
    public boolean weakCompareAndSet(boolean expect, boolean update) {
        int e = expect ? 1 : 0;
        int u = update ? 1 : 0;
        return unsafe.compareAndSwapInt(this, valueOffset, e, u);
    }

    /**
     * Unconditionally sets to the given value.
     *
     * @param newValue the new value
     */
    /**
     * 无条件地设置为给定值。
     * @param newValue 新值
     */
    public final void set(boolean newValue) {
        value = newValue ? 1 : 0;
    }

    /**
     * Eventually sets to the given value.
     *
     * @param newValue the new value
     * @since 1.6
     */
    /**
     * 最终设置为给定值。
     * @param newValue 新值
     */
    public final void lazySet(boolean newValue) {
        int v = newValue ? 1 : 0;
        unsafe.putOrderedInt(this, valueOffset, v);
    }

    /**
     * Atomically sets to the given value and returns the previous value.
     *
     * @param newValue the new value
     * @return the previous value
     */
    /**
     * 以原子方式设置为给定值，并返回以前的值。
     * @param  newValue 新值
     * @return          以前的值
     */
    public final boolean getAndSet(boolean newValue) {
        for (;;) {
            boolean current = get();
            if (compareAndSet(current, newValue))
                return current;
        }
    }

    /**
     * Returns the String representation of the current value.
     * @return the String representation of the current value.
     */
    /**
     * 返回当前值的字符串表示形式。
     * @return 当前值的字符串表示形式。
     */
    public String toString() {
        return Boolean.toString(get());
    }

}