笑谈java并发编程一之AtomicBoolean介绍

Java的java.util.concurrent.atomic这个包下提供了很多的原子性操作的api，可供在多线程中保证操作的原子性，不会发生线程不安全的操作

1. 实现某个时间段只能有一个工作人员进行工作的实例，线程不安全代码如下：

public class BarWorker implements Runnable {    //设置某段时间内只能有一个工作人员进行工作，其他的只能放弃工作的机会     private static boolean exists = false;         private String name;     public BarWorker(String name) {          this.name = name;         }         @Override     public void run() {              if (!exists) {             try {                 TimeUnit.SECONDS.sleep(1);             } catch (InterruptedException e) {                 e.printStackTrace();             }             exists = true;             System.out.println(name + " enter");                 try {                      System.out.println(name + " working");                      TimeUnit.SECONDS.sleep(2);                     } catch (InterruptedException e) {                     e.printStackTrace();                 }                 System.out.println(name + " leave");                     exists = false;            } else {             System.out.println(name + " give up");            }        }     public static void main(String[] args) throws InterruptedException {         BarWorker bar1 = new BarWorker("bar1");         BarWorker bar2 = new BarWorker("bar2");           new Thread(bar1).start();         new Thread(bar2).start();    }}

输出结果如下：

bar1 enterbar2 enterbar1 workingbar2 workingbar2 leavebar1 leave

结论：可以看到同时有两个员工进入工作了，这是因为在exists在判断和更新中间不是原子性的操作，中间我利用线程延迟等待了1秒钟，当第二个工人进入以后，发现exists还是false，所以还是可以进入工作的，这样的话问题就出现了，最主要的问题还是在判断和更新之间出现了其他的工作处理。当然，如果把判断和更新之间的等待去除的话基本也不会出现上述问题，但是不能完全保证，在这种情况下可以采取同步synchronized的办法处理！但是真的必须这样吗？其实不尽然，聪明的java大师们为我们提供了原子性操作的AtomicBoolean工具

1. AtomicBoolean解决上述问题的代码方案：

import java.util.concurrent.TimeUnit;import java.util.concurrent.atomic.AtomicBoolean;public class BarWorkerAuto implements Runnable {    //设置某段时间内只能有一个工作人员进行工作，其他的只能放弃工作的机会     private static AtomicBoolean exists = new AtomicBoolean(false);     private String name;     public BarWorkerAuto(String name) {          this.name = name;         }         @Override     public void run() {              if (exists.compareAndSet(false,true)) {             System.out.println(name + " enter");                 try {                      System.out.println(name + " working");                      TimeUnit.SECONDS.sleep(2);                     } catch (InterruptedException e) {                     e.printStackTrace();                 }                 System.out.println(name + " leave");             exists.set(false);        } else {             System.out.println(name + " give up");            }        }     public static void main(String[] args) throws InterruptedException {         BarWorkerAuto bar1 = new BarWorkerAuto("bar1");         BarWorkerAuto bar2 = new BarWorkerAuto("bar2");         new Thread(bar1).start();         new Thread(bar2).start();    }}

输出结果如下：

bar1 enterbar2 give upbar1 workingbar1 leave

结论：可以看到同一时间内只有一个工人进入工作，因为AtomicBoolean的compareAndSet这个方法是原子性操作，首先判断当前值是否与expect的值相等，如果相等则把值更新update

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