AtomicBoolean介绍与使用

刺骨的言语ヽ痛彻心扉 2022-05-26 04:52 201阅读 0赞

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

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

看如下代码：

**\[html\]**  [view plain][]   [copy][view plain]

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][view plain]

1.  bar1 enter  
2.  bar2 enter  
3.  bar1 working  
4.  bar2 working  
5.  bar1 leave  
6.  bar2 leave

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

**\[html\]**  [view plain][]   [copy][view plain]

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][view plain]

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

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

[view plain]: https://blog.csdn.net/zmx729618/article/details/52767736#