AtomicBoolean类解析

2019-04-01  本文已影响0人  摆渡时光

一、变量含义

AtomicBoolean主要原子操作boolean类型数据。下面第二行valueOffset记录了value变量的内存地址,用于原子操作value的值。后面会说到compareAndSet等方法都会用到这个内存地址。我们可以看到static方法里面利用unsafe的objectFieldOffset方法获取了字段内存地址。


private static final Unsafeunsafe = 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;

value被定义为volatile变量,volatile具有可见性、有序性,不具备原子性,主要是为了解决多线程对同一个变量的读写并发问题。

原子性:也就是操作事原子性的,不会出现修改了一半的情况,这好理解。

可见性:多个线程同时并发修改这个value,各个线程也可以实时读取到修改后的值。

有序性:这里主要针对编译器和处理器对指令进行重排序,也就是volatile修饰的变量不会出现指令重排序,其他例如通过synchronized和Lock也可以保证有序性。

二、原子性与CAS

那么问题来了,既然value能够保证原子性,那么下面的结果是10000吗?

public class Test {
    public volatile int inc = 0;
    public void increase() {
        inc++;
    }
    public static void main(String[] args) {
        final Test test = new Test();
        for(int i=0;i<10;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<1000;j++)
                        test.increase();
                };
            }.start();
        }
        while(Thread.activeCount()>1) //保证前面的线程都执行完
            Thread.yield();
        System.out.println(test.inc);
    }
}

答案是不行,原因是上面说的原子性指的“读”是原子性的,不包括写。AtomicBoolean通过compareAndSet方法来保证写操作的原子性,如下代码所示,设置变量value值为为u,并要求变量当前值为e

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);
}

使用了CAS操作,最终调用了unsafe的compareAndSwapInt方法

/***
  * Compares the value of the integer field at the specified offset
  * in the supplied object with the given expected value, and updates
  * it if they match.  The operation of this method should be atomic,
  * thus providing an uninterruptible way of updating an integer field.
  * 在obj的offset位置比较integer field和期望的值,如果相同则更新。这个方法
  * 的操作应该是原子的,因此提供了一种不可中断的方式更新integer field。
  *
  * @param obj the object containing the field to modify.
  *            包含要修改field的对象
  * @param offset the offset of the integer field within <code>obj</code>.
  *              <code>obj</code>中整型field的偏移量
  * @param expect the expected value of the field.
  *              希望field中存在的值
  * @param update the new value of the field if it equals <code>expect</code>.
  *          如果期望值expect与field的当前值相同,设置filed的值为这个新值
  * @return true if the field was changed.
  *                            如果field的值被更改
  */
public native boolean compareAndSwapInt(Object obj, long offset, intexpect, int update);

set(boolean newValue)和lazySet(boolean newValue)方法比较有意思。set方法好理解,lazySet使用了putOrderedInt方法,其实就是就是不使用内存屏障,修改后,不对其它线程理解可见,是对上面compareAndSwapInt功能的弱化

/**
* Unconditionally sets to the given value.
*
* @param newValue the new value
*/
public final void set(boolean newValue) {
  value = newValue ?1 :0;
}
/**
* Eventually sets to the given value.
*
* @param newValue the new value
* @since 1.6
*/
public final void lazySet(boolean newValue) {
int v = newValue ?1 :0;
    unsafe.putOrderedInt(this, valueOffset, v);
}

另外还有weakCompareAndSet看名字就知道是一个不保证返回结果的方法,jdk暂未实现。

上一篇 下一篇

猜你喜欢

热点阅读