并发读源码——AtomicBoolean

阳光穿透心脏的1/2处 2023-01-12 04:29 33阅读 0赞

### 文章目录 ###

*  1、AtomicBoolean介绍
 *  2、源码解析
 *  3、多线程用法

# 1、AtomicBoolean介绍 #

[上一节][Link 1]介绍了AtomicInteger加减操作的原子性，通过乐观锁实现，本节介绍AtomicBoolean，该类实现了对布尔类型比较和设置封装为原子操作。AtomicBoolean的源码以及用于都与AtomicInteger类似，可以参考上篇文章。例如如下操作

if(flag == true){ 
    	flag = false;
    }

该操作是线程不安全的，如果用AtomicBoolean类型封装布尔类型，就可以通过内部的compareAndSet方法实现布尔类型比较和设置的原子性，该方法也是通过乐观锁实现，后续进行分析。

# 2、源码解析 #

package java.util.concurrent.atomic;
    
    import sun.misc.Unsafe;
    
    
    public class AtomicBoolean implements java.io.Serializable { 
        private static final long serialVersionUID = 4654671469794556979L;
        // setup to use Unsafe.compareAndSwapInt for updates
        private static final Unsafe unsafe = Unsafe.getUnsafe();
        private static final long valueOffset;
    
        static { 
            try { 
                valueOffset = unsafe.objectFieldOffset
                    (AtomicBoolean.class.getDeclaredField("value"));
            } catch (Exception ex) {  throw new Error(ex); }
        }
    
        /*上一节中介绍了AtomicInteger，是调用底层的compareAndSwapInt进行比较设置值的，但是JVM没有compareAndSwapBoolean， * 所以AtomicBoolean就借鉴了AtomicInteger，通过把boolean类型转换成int类型，然后调用底层的compareAndSwapInt设置布尔类型的值 * 当布尔类型值为true时，value的值转化为 1，false时，转化为0，可以参考下面的方法 * */
        private volatile int value;
    
        /*AtomicBoolean有参初始化*/
        /*初始化布尔类型为true时，value的值转化为1，false时，value的值转化为0*/
        public AtomicBoolean(boolean initialValue) { 
            value = initialValue ? 1 : 0;
        }
    
        /*无参初始化*/
        public AtomicBoolean() { 
        }
    
        /*获取AtomicBoolean的变量value值*/
        public final boolean get() { 
            return value != 0;
        }
    
        /*更新update值时，先比较expect与value的值是否相等，相等就把update的值更新到value中，否则更新失败*/
        /*运用该方法时，可以先从AtomicBoolean中读出value的值放到expect中，等更新update值时，如果expect中的值等于 * AtomicBoolean中value值，说明在此期间没有其他线程操作value，线程是安全的，update更新成功；如果expect不等于 * AtomicBoolean中value值，说明在此期间有其他线程操作了value，改变了value值，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);
        }
    
        /*weakCompareAndSet与compareAndSet功能类似，都是比较expect值，然后更新update的值 * 但是weakCompareAndSet不插入内存屏障，不能保证volatile或者final变量在内存中的执行顺序，只能保证最终一致性 * 例如expect与AtomicBoolean中的value变量进行比较时，由于未出入内存屏障，value值没有从主内存中读取，导致比较的结果不准 * */
        public boolean weakCompareAndSet(boolean expect, boolean update) { 
            int e = expect ? 1 : 0;
            int u = update ? 1 : 0;
            return unsafe.compareAndSwapInt(this, valueOffset, e, u);
        }
    
        /*修改value值*/
        public final void set(boolean newValue) { 
            value = newValue ? 1 : 0;
        }
    
        /*putOrderedInt不会立即把设置的newValue值同步到主内存中，但最终会进行同步，也就是只能最终一致性，一般很少用*/
        public final void lazySet(boolean newValue) { 
            int v = newValue ? 1 : 0;
            unsafe.putOrderedInt(this, valueOffset, v);
        }
    
        /*先获取value值，然后把要更新的newValue值更新到value中，整个过程保证了原子性，是线程安全的*/
        /*采用乐观锁的方式更新布尔类型*/
        public final boolean getAndSet(boolean newValue) { 
            boolean prev;
            do { 
                prev = get();
            } while (!compareAndSet(prev, newValue));
            return prev;
        }
    
     
        public String toString() { 
            return Boolean.toString(get());
        }
    
    }

# 3、多线程用法 #

package com.lzj.atomic.integer.boolean1;
    
    import java.util.concurrent.atomic.AtomicBoolean;
    
    public class AtomicBooleanDemo { 
    	
    	private AtomicBoolean atomicBoolean = new AtomicBoolean(false);
    	
    	public boolean read() { 
    		return atomicBoolean.get();
    	}
    	
    	/*判断atomicBoolean中的value值是否是true，如果是，把value值更新我false，writeFlase执行结束；如果否，就执行do action操作，并循环执行while操作，直到value中的值为true*/
    	public void writeFalse() { 
    		while(!atomicBoolean.compareAndSet(true, false)) { 
    			/*do action*/
    			System.out.println(Thread.currentThread() + ": 当前线程设置atomicBoolean的value值false失败，因为atomicBoolean当前的value值为false");
    		}
    		System.out.println(Thread.currentThread() + ": 当前线程设置atomicBoolean的value值false成功，因为atomicBoolean当前的value值为true");
    	}
    	
    	/*1秒后，把atomicBoolean中的value值设置为true*/
    	public void set() throws InterruptedException { 
    		Thread.sleep(1);
    		atomicBoolean.set(true);
    	}
    	
    	public static void main(String[] args) { 
    		AtomicBooleanDemo atomicBooleanDemo = new AtomicBooleanDemo();
    		Runnable run1 = () -> atomicBooleanDemo.writeFalse();
    		Runnable run2 = () -> { 
    			try { 
    				atomicBooleanDemo.set();
    			} catch (InterruptedException e) { 
    				e.printStackTrace();
    			}
    		};
    		
    		Thread thread1 = new Thread(run1);
    		Thread thread2 = new Thread(run2);
    		thread1.start();
    		thread2.start();
    	}
    
    }

执行结果如下：

Thread[Thread-0,5,main]: 当前线程设置atomicBoolean的value值false失败，因为atomicBoolean当前的value值为false
    Thread[Thread-0,5,main]: 当前线程设置atomicBoolean的value值false失败，因为atomicBoolean当前的value值为false
    Thread[Thread-0,5,main]: 当前线程设置atomicBoolean的value值false失败，因为atomicBoolean当前的value值为false
    Thread[Thread-0,5,main]: 当前线程设置atomicBoolean的value值false失败，因为atomicBoolean当前的value值为false
    Thread[Thread-0,5,main]: 当前线程设置atomicBoolean的value值false失败，因为atomicBoolean当前的value值为false
    Thread[Thread-0,5,main]: 当前线程设置atomicBoolean的value值false失败，因为atomicBoolean当前的value值为false
    Thread[Thread-0,5,main]: 当前线程设置atomicBoolean的value值false失败，因为atomicBoolean当前的value值为false
    Thread[Thread-0,5,main]: 当前线程设置atomicBoolean的value值false失败，因为atomicBoolean当前的value值为false
    Thread[Thread-0,5,main]: 当前线程设置atomicBoolean的value值false失败，因为atomicBoolean当前的value值为false
    Thread[Thread-0,5,main]: 当前线程设置atomicBoolean的value值false失败，因为atomicBoolean当前的value值为false
    Thread[Thread-0,5,main]: 当前线程设置atomicBoolean的value值false失败，因为atomicBoolean当前的value值为false
    Thread[Thread-0,5,main]: 当前线程设置atomicBoolean的value值false失败，因为atomicBoolean当前的value值为false
    Thread[Thread-0,5,main]: 当前线程设置atomicBoolean的value值false失败，因为atomicBoolean当前的value值为false
    Thread[Thread-0,5,main]: 当前线程设置atomicBoolean的value值false失败，因为atomicBoolean当前的value值为false
    Thread[Thread-0,5,main]: 当前线程设置atomicBoolean的value值false失败，因为atomicBoolean当前的value值为false
    Thread[Thread-0,5,main]: 当前线程设置atomicBoolean的value值false失败，因为atomicBoolean当前的value值为false
    Thread[Thread-0,5,main]: 当前线程设置atomicBoolean的value值false失败，因为atomicBoolean当前的value值为false
    Thread[Thread-0,5,main]: 当前线程设置atomicBoolean的value值false失败，因为atomicBoolean当前的value值为false
    Thread[Thread-1,5,main]: 设置atomicBoolean的value值为true
    Thread[Thread-0,5,main]: 当前线程设置atomicBoolean的value值false成功，因为atomicBoolean当前的value值为true

可见，开始Thread-0一直在循环执行while操作，当Thread-1线程把value值设置为true后，Thread-0结束while循环操作。

atomicBoolean.compareAndSet(true, false)是原子性，避免了线程不安全操作，该操作功能相当于如下操作

public void setFlag(boolean flag) { 
    	if(flag == true) { 
    		//do action
    		flag = false;
    	}
    }

如代码所示，是先判断flag是否等于true，如果是，则把flag设置为false。该过程是线程不安全的，比如线程1判断flag == true，满足条件后，在执行flag = false操作之前，线程2把flag=false。

[Link 1]: https://blog.csdn.net/u010502101/article/details/113086328