并发编程--原子类AtomicLong、AtomicBoolean和AtomicReference

曾经终败给现在 2022-06-18 08:14 298阅读 0赞

在上一篇博客[ 并发编程--原子类AotmicInteger][_--_AotmicInteger]中我们已经简单介绍了一下AtomicInteger相关的知识，简单来说AtomicLong的实现原理与AtomicInteger是相同的，用volatile来修饰变量value和使用sun.misc.Unsafe来完成对value的原子操作。

AtomicBoolean的实现机制还是比较简单的，通过判断用volatile修改的value与1和0之间的关系来返回true和false，使用sun.misc.Unsafe来完成对value的原子操作

AtomicReference的实现机制就是通过sun.misc.Unsafe来对对象引用进行原子操作。

源码如下：

public class AtomicLong extends Number implements java.io.Serializable {
        private static final long serialVersionUID = 1927816293512124184L;
    
        
        private static final Unsafe unsafe = Unsafe.getUnsafe();
        private static final long valueOffset;
    
      
        static final boolean VM_SUPPORTS_LONG_CAS = VMSupportsCS8();
    
        private static native boolean VMSupportsCS8();
    
        static {
            try {
                valueOffset = unsafe.objectFieldOffset
                    (AtomicLong.class.getDeclaredField("value"));
            } catch (Exception ex) { throw new Error(ex); }
        }
    
        private volatile long value;
    
       
        public AtomicLong(long initialValue) {
            value = initialValue;
        }
    
        public AtomicLong() {
        }
    
        public final long get() {
            return value;
        }
    
      
        public final void set(long newValue) {
            value = newValue;
        }
    
        public final void lazySet(long newValue) {
            unsafe.putOrderedLong(this, valueOffset, newValue);
        }
    
        public final long getAndSet(long newValue) {
            return unsafe.getAndSetLong(this, valueOffset, newValue);
        }
    
        public final boolean compareAndSet(long expect, long update) {
            return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
        }
    
        public final boolean weakCompareAndSet(long expect, long update) {
            return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
        }
    
        public final long getAndIncrement() {
            return unsafe.getAndAddLong(this, valueOffset, 1L);
        }
    
        public final long getAndDecrement() {
            return unsafe.getAndAddLong(this, valueOffset, -1L);
        }
    
        public final long getAndAdd(long delta) {
            return unsafe.getAndAddLong(this, valueOffset, delta);
        }
    
       
        public final long incrementAndGet() {
            return unsafe.getAndAddLong(this, valueOffset, 1L) + 1L;
        }
    
        public final long decrementAndGet() {
            return unsafe.getAndAddLong(this, valueOffset, -1L) - 1L;
        }
    
        public final long addAndGet(long delta) {
            return unsafe.getAndAddLong(this, valueOffset, delta) + delta;
        }
    
       
        public final long getAndUpdate(LongUnaryOperator updateFunction) {
            long prev, next;
            do {
                prev = get();
                next = updateFunction.applyAsLong(prev);
            } while (!compareAndSet(prev, next));
            return prev;
        }
    
        public final long updateAndGet(LongUnaryOperator updateFunction) {
            long prev, next;
            do {
                prev = get();
                next = updateFunction.applyAsLong(prev);
            } while (!compareAndSet(prev, next));
            return next;
        }
    
        public final long getAndAccumulate(long x,
                                           LongBinaryOperator accumulatorFunction) {
            long prev, next;
            do {
                prev = get();
                next = accumulatorFunction.applyAsLong(prev, x);
            } while (!compareAndSet(prev, next));
            return prev;
        }
    
        public final long accumulateAndGet(long x,
                                           LongBinaryOperator accumulatorFunction) {
            long prev, next;
            do {
                prev = get();
                next = accumulatorFunction.applyAsLong(prev, x);
            } while (!compareAndSet(prev, next));
            return next;
        }
    
       
        public String toString() {
            return Long.toString(get());
        }
    
        public int intValue() {
            return (int)get();
        }
    
        public long longValue() {
            return get();
        }
    
        public float floatValue() {
            return (float)get();
        }
    
        public double doubleValue() {
            return (double)get();
        }
    
    }

AtomicBoolean的源码：

public class AtomicBoolean implements java.io.Serializable {
        private static final long serialVersionUID = 4654671469794556979L;
    
        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); }
        }
    
        private volatile int value;
    
       
        public AtomicBoolean(boolean initialValue) {
            value = initialValue ? 1 : 0;
        }
    
        public AtomicBoolean() {
        }
    
        public final boolean get() {
            return value != 0;
        }
    
        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);
        }
    
       
        public boolean weakCompareAndSet(boolean expect, boolean update) {
            int e = expect ? 1 : 0;
            int u = update ? 1 : 0;
            return unsafe.compareAndSwapInt(this, valueOffset, e, u);
        }
    
      
        public final void set(boolean newValue) {
            value = newValue ? 1 : 0;
        }
    
        public final void lazySet(boolean newValue) {
            int v = newValue ? 1 : 0;
            unsafe.putOrderedInt(this, valueOffset, v);
        }
    
        public final boolean getAndSet(boolean newValue) {
            boolean prev;
            do {
                prev = get();
            } while (!compareAndSet(prev, newValue));
            return prev;
        }
    
        public String toString() {
            return Boolean.toString(get());
        }
    
    }

AtomicReference源码：

public class AtomicReference<V> implements java.io.Serializable {
        private static final long serialVersionUID = -1848883965231344442L;
    
        private static final Unsafe unsafe = Unsafe.getUnsafe();
        private static final long valueOffset;
    
        static {
            try {
                valueOffset = unsafe.objectFieldOffset
                    (AtomicReference.class.getDeclaredField("value"));
            } catch (Exception ex) { throw new Error(ex); }
        }
    
        private volatile V value;
    
       
        public AtomicReference(V initialValue) {
            value = initialValue;
        }
    
        public AtomicReference() {
        }
    
     
        public final V get() {
            return value;
        }
    
        public final void set(V newValue) {
            value = newValue;
        }
    	
        public final void lazySet(V newValue) {
            unsafe.putOrderedObject(this, valueOffset, newValue);
        }
    
       
        public final boolean compareAndSet(V expect, V update) {
            return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
        }
    
        
        public final boolean weakCompareAndSet(V expect, V update) {
            return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
        }
    
      
        @SuppressWarnings("unchecked")
        public final V getAndSet(V newValue) {
            return (V)unsafe.getAndSetObject(this, valueOffset, newValue);
        }
    
        public final V getAndUpdate(UnaryOperator<V> updateFunction) {
            V prev, next;
            do {
                prev = get();
                next = updateFunction.apply(prev);
            } while (!compareAndSet(prev, next));
            return prev;
        }
    
        public final V updateAndGet(UnaryOperator<V> updateFunction) {
            V prev, next;
            do {
                prev = get();
                next = updateFunction.apply(prev);
            } while (!compareAndSet(prev, next));
            return next;
        }
    
        public final V getAndAccumulate(V x,
                                        BinaryOperator<V> accumulatorFunction) {
            V prev, next;
            do {
                prev = get();
                next = accumulatorFunction.apply(prev, x);
            } while (!compareAndSet(prev, next));
            return prev;
        }
    
       
        public final V accumulateAndGet(V x,
                                        BinaryOperator<V> accumulatorFunction) {
            V prev, next;
            do {
                prev = get();
                next = accumulatorFunction.apply(prev, x);
            } while (!compareAndSet(prev, next));
            return next;
        }
    
        
        public String toString() {
            return String.valueOf(get());
        }
    
    }

[_--_AotmicInteger]: http://blog.csdn.net/qq924862077/article/details/68943417