AtomicBoolean

AtomicBoolean是Java.util.concurrent.atomic包下的原子变量，这个包里面提供了一组原子类。其基本的特性就是在多线程环境下，当有多个线程同时执行这些类的实例包含的方法时，具有排他性，即当某个线程进入方法，执行其中的指令时，不会被其他线程打断，而别的线程就像自旋锁一样，一直等到该方法执行完成，才由JVM从等待队列中选择一个另一个线程进入，这只是一种逻辑上的理解。实际上是借助硬件的相关指令来实现的，不会阻塞线程(或者说只是在硬件级别上阻塞了)。
例如AtomicBoolean，在这个Boolean值的变化的时候不允许在之间插入，保持操作的原子性。方法和举例：compareAndSet(boolean expect, boolean update)。这个方法主要两个作用

  1. 比较AtomicBoolean和expect的值，如果一致，执行方法内的语句。其实就是一个if语句
  2. 把AtomicBoolean的值设成update比较最要的是这两件事是一气呵成的，这连个动作之间不会被打断，任何内部或者外部的语句都不可能在两个动作之间运行。为多线程的控制提供了解决的方案。看如下代码： ```java package com.example;

import java.util.concurrent.TimeUnit;

public class BarWorker implements Runnable {

  1. private static boolean exists = false;
  3. private String name;
  5. public BarWorker(String name) {
  6.     this.name = name;
  7. }
  9. @Override
  10. public void run() {
  11.     if (!exists) {
  12.         try {
  13.             TimeUnit.SECONDS.sleep(1);
  14.         } catch (InterruptedException e1) {
  15.             // do nothing
  16.         }
  17.         exists = true;
  18.         System.out.println(name + " enter");
  19.         try {
  20.             System.out.println(name + " working");
  21.             TimeUnit.SECONDS.sleep(2);
  22.         } catch (InterruptedException e) {
  23.             // do nothing
  24.         }
  25.         System.out.println(name + " leave");
  26.         exists = false;
  27.     } else {
  28.         System.out.println(name + " give up");
  29.     }
  30. }
  33. public static void main(String[] args) {
  35.     BarWorker bar1 = new BarWorker("bar1");
  36.     BarWorker bar2 = new BarWorker("bar2");
  37.     new Thread(bar1).start();
  38.     new Thread(bar2).start();
  39. }

}

  1. 该代码使用static变量exists用来实现同一时间只有一个worker在工作. 但是假设exists的判断和exists = true;之间有了 其他指令呢？ 输出如下：
  2. ```java
  3. bar1 enter  
  4. bar2 enter  
  5. bar1 working  
  6. bar2 working  
  7. bar1 leave  
  8. bar2 leave

可以看到两个线程同时工作了。这时可以用AtomicBoolean进行线程同步，代码如下：

  1. package com.example;
  3. import java.util.concurrent.TimeUnit;
  4. import java.util.concurrent.atomic.AtomicBoolean;
  6. public class BarWorker2 implements Runnable {
  8.     private static AtomicBoolean exists = new AtomicBoolean(false);
  10.     private String name;
  12.     public BarWorker2(String name) {
  13.         this.name = name;
  14.     }
  16.     @Override
  17.     public void run() {
  18.         if (exists.compareAndSet(false, true)) {
  20.             System.out.println(name + " enter");
  21.             try {
  22.                 System.out.println(name + " working");
  23.                 TimeUnit.SECONDS.sleep(2);
  24.             } catch (InterruptedException e) {
  25.                 // do nothing    
  26.             }
  27.             System.out.println(name + " leave");
  28.             exists.set(false);
  29.         } else {
  30.             System.out.println(name + " give up");
  31.         }
  33.     }
  36.     public static void main(String[] args) {
  37.         BarWorker2 bar1 = new BarWorker2("bar1");
  38.         BarWorker2 bar2 = new BarWorker2("bar2");
  39.         new Thread(bar1).start();
  40.         new Thread(bar2).start();
  41.     }
  42. }

执行结果如下：

  1. bar1 enter  
  2. bar1 working  
  3. bar2 give up  
  4. bar1 leave

可以看出仅仅一个线程进行工作，因为exists.compareAndSet(false, true)提供了原子性操作，比较和赋值操作组成了一个原子操作, 中间不会提供可乘之机。