atomic包之AtomicBoolean

atomic简介

atomic意思是原子；atomic是java.util.concurrent下的专门为线程安全设计的Java包，包含多个原子操作类，主要通过CAS（Compare And Set）来确保多线程下操作的安全性；

AtomicBoolean

• 源码

  public class AtomicBoolean implements java.io.Serializable {
  private static final long serialVersionUID = 4654671469794556979L;
  private static final Unsafe unsafe = Unsafe.getUnsafe();
  private static final long valueOffset;
  static {
      try {
          // 通过unsafe获取value的内存地址
          valueOffset = unsafe.objectFieldOffset
              (AtomicBoolean.class.getDeclaredField("value"));
      } catch (Exception ex) { throw new Error(ex); }
  }
  // value 被定义为volatile（内存可见）
  private volatile int value;
  // 构造方法：true用1表示
  public AtomicBoolean(boolean initialValue) {
      value = initialValue ? 1 : 0;
  }
  public AtomicBoolean() {
  }
  public final boolean get() {
      // 默认为false
      return value != 0;
  }
  public final boolean compareAndSet(boolean expect, boolean update) {
      int e = expect ? 1 : 0;
      int u = update ? 1 : 0;
      //通过调用unsafe的native方法来实现CAS操作，jdk的注释是：
      //如果valueOffset的内存地址的存储的值为e，那么将值更新为u；
      //该native方法通过调用硬件来搞定，而value又定义为volatile，就可以实现线程安全
      return unsafe.compareAndSwapInt(this, valueOffset, e, u);
  }
  public boolean weakCompareAndSet(boolean expect, boolean update) {
      int e = expect ? 1 : 0;
      int u = update ? 1 : 0;
      return unsafe.compareAndSwapInt(this, valueOffset, e, u);
  }
  public final void set(boolean newValue) {
      value = newValue ? 1 : 0;
  }
  public final void lazySet(boolean newValue) {
      int v = newValue ? 1 : 0;
      unsafe.putOrderedInt(this, valueOffset, v);
  }
  public final boolean getAndSet(boolean newValue) {
      boolean prev;
      do {
          prev = get();
      } while (!compareAndSet(prev, newValue));
      return prev;
  }
  public String toString() {
      return Boolean.toString(get());
  }
  }

总结

atomic是通过cpu来进行硬件上的阻塞及volatile来实现原子操作的线程安全的；所以在java语言层面是非阻塞的，但是在底层硬件上是阻塞的；

在这里提一下volatile关键字，用volatile定义的变量是内存可见的，其实现也是通过硬件来实现的；处理器识别到从内存中读取的数据是可缓存的，则处理器读取整个缓存行到缓存，下次访问的时候从缓存中读取，当用volatile修饰的变量有了修改，会生成一条lock前缀的指令，lock指令做了两件事情：

• 将当前处理器的缓存行的数据刷到内存中；
• 使其他cpu缓存了这个地址的数据无效，重新从内存读取，这样就实现了volatile修饰的变量内存可见