AtomicBoolean

只见惊鸿

于 2021-06-09 16:36:33 发布

阅读量9.8k

点赞数 5

分类专栏：原子类之atomic包

本文链接：https://blog.csdn.net/u014307520/article/details/117730392

版权

原子类之atomic包专栏收录该内容

1 篇文章 1 订阅

订阅专栏

一、介绍

AtomicBoolean是通过原子方式更新 boolean 值。AtomicBoolean用于诸如原子更新标志之类的应用程序，但是不能替换boolean类使用。

二、原理

AtomicBoolean 内部持有了一个 volatile变量修饰的value，
底层通过对象在内存中的偏移量(valueOffset)对应的旧值与当前值进行比较，
相等则更新并返回true；否则返回false。

即CAS的交换思想. 
AtomicBoolean 内部可以保证，在高并发情况下，同一时刻只有一个线程对变量修改成功。

/**
* Atomically update Java variable to <tt>x</tt> if it is currently
* holding <tt>expected</tt>.
* @return <tt>true</tt> if successful
*/
public final native boolean compareAndSwapInt(Object o, long offset,
                                              int expected,
                                              int x);

Unsafe.compareAndSwapInt()介绍

三、应用
1、AtomicBoolean 示例

public class AtomicBooleanDemo1 {

    // 设置初始化值为false，参数通过cas操作更新为true
    private static AtomicBoolean initialized = new AtomicBoolean(false);

    public void init() {
        if (initialized.compareAndSet(false, true)) {
            // 此处只会有一个线程进入
            System.out.println(Thread.currentThread().getName() + " init success");
        } else {
            System.out.println(Thread.currentThread().getName() + " cas 失败");
        }
    }

    public static void main(String[] args) {
        final AtomicBooleanDemo1 demo1 = new AtomicBooleanDemo1();

        for (int i = 0; i < 100; i++) {
            new Thread(new Runnable() {
                public void run() {
                    demo1.init();
                }
            }).start();
        }

    }
}

2、使用volatile 替换


public class AtomicBooleanDemo2 {

    // 设置初始化值为false，通过volatile变量保证线程可见性
    private static volatile boolean initialized;

    public void init() {
        if (initialized == false) {
            initialized = true;
            // 此处只会有一个线程进入
            System.out.println(Thread.currentThread().getName() + " init success");
        } else {
            System.out.println(Thread.currentThread().getName() + " cas 失败");
        }
    }

    public static void main(String[] args) throws Exception {
        final AtomicBooleanDemo2 demo1 = new AtomicBooleanDemo2();

        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                public void run() {
                    demo1.init();
                }
            }).start();
        }

    }
}

针对这种boolean类型的并发操作，可以使用AtomicBoolean进行设置即可

三、源码分析

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静态块，随AtomicBoolean 类加载时执行一次，可见valueOffset针对所有对象在内存中的映射    
    // 值都是同一个
    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicBoolean.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;

    // 构造函数，对value赋默认值
    public AtomicBoolean(boolean initialValue) {
        value = initialValue ? 1 : 0;
    }
   
    // 无参构造，value默认值为0
    public AtomicBoolean() {
    }

}

将expect和AtomicBoolean的value进行比较，若一致则更新为update，否则返回false

    /**
     * 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 {@code true} if successful. False return indicates that
     * the actual value was not equal to the expected value.
     */
    public final boolean compareAndSet(boolean expect, boolean update) {
        int e = expect ? 1 : 0;
        int u = update ? 1 : 0;
        // 通过unsafe的cas方法操作，比较并替换，底层通过lock前缀加锁实现原子性
        return unsafe.compareAndSwapInt(this, valueOffset, e, u);
    }