AtomicBoolean介绍与使用

Biegral 2018/4/25 15:20:00 741

      AtomicBoolean是java.util.concurrent.atomic包下的原子变量，这个包里面提供了一组原子类。其基本的特性就是在多线程环境下，当有多个线程同时执行这些类的实例包含的方法时，具有排他性，即当某个线程进入方法，执行其中的指令时，不会被其他线程打断，而别的线程就像自旋锁一样，一直等到该方法执行完成，才由JVM从等待队列中选择一个另一个线程进入，这只是一种逻辑上的理解。实际上是借助硬件的相关指令来实现的，不会阻塞线程(或者说只是在硬件级别上阻塞了)。

      例如AtomicBoolean，在这个Boolean值的变化的时候不允许在之间插入，保持操作的原子性。方法和举例：compareAndSet(boolean expect, boolean update)。这个方法主要两个作用         1. 比较AtomicBoolean和expect的值，如果一致，执行方法内的语句。其实就是一个if语句         2. 把AtomicBoolean的值设成update         比较最要的是这两件事是一气呵成的，这连个动作之间不会被打断，任何内部或者外部的语句都不可能在两个动作之间运行。为多线程的控制提供了解决的方案。

     看如下代码：

[html] view plain copy
  1. package zmx.atomic.test;  
  2.   
  3. import java.util.concurrent.TimeUnit;  
  4.   
  5. public class BarWorker implements Runnable {  
  6.       
  7.      private static boolean exists = false;    
  8.         
  9.      private String name;    
  10.          
  11.      public BarWorker(String name) {     
  12.           this.name = name;    
  13.      }    
  14.        
  15.      @Override    
  16.      public void run() {     
  17.          if (!exists) {    
  18.                  try {    
  19.                   TimeUnit.SECONDS.sleep(1);    
  20.                  } catch (InterruptedException e1) {    
  21.                   // do nothing    
  22.                  }    
  23.                  exists = true;    
  24.                  System.out.println(name + " enter");    
  25.                  try {    
  26.                   System.out.println(name + " working");    
  27.                   TimeUnit.SECONDS.sleep(2);    
  28.                  } catch (InterruptedException e) {    
  29.                   // do nothing    
  30.                  }    
  31.                  System.out.println(name + " leave");    
  32.                  exists = false;    
  33.         } else {    
  34.          System.out.println(name + " give up");    
  35.         }    
  36.     
  37.     }   
  38.        
  39.        
  40.      public static void main(String[] args) {  
  41.            
  42.          BarWorker bar1 = new BarWorker("bar1");  
  43.          BarWorker bar2 = new BarWorker("bar2");  
  44.          new Thread(bar1).start();  
  45.          new Thread(bar2).start();  
  46.            
  47.            
  48.           
  49.     }  
  50.   
  51.   
  52. }  


 

       该代码使用static变量exists用来实现同一时间只有一个worker在工作. 但是假设exists的判断和exists = true;之间有了 其他指令呢？ 输出如下：

[html] view plain copy
  1. bar1 enter  
  2. bar2 enter  
  3. bar1 working  
  4. bar2 working  
  5. bar1 leave  
  6. bar2 leave  

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

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

执行结果如下：

[html] view plain copy
  1. bar1 enter  
  2. bar1 working  
  3. bar2 give up  
  4. bar1 leave  


 

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

阅读排行

分类

归档