笑谈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 enter
bar2 enter
bar1 working
bar2 working
bar2 leave
bar1 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 enter
bar2 give up
bar1 working
bar1 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);
    }