Java原子类

  • 作用
  • 原子类有哪些
  • 基本类型的原子类
  • 源码分析(实现原理)
  • Usage
  • 引用类型的原子类
  • 源码分析(实现原理)
  • 原子的updater
  • 源码分析(实现原理)
  • 其他


作用

原子类的目的就是在并发环境下保证线程安全,并且保证效率。

原子类有哪些

Java的原子类在java.util.concurrent.atomic包下,包内有16个类(jdk8)

java 原子结构 java原子类原理_多线程

基本类型的原子类

  • AtomicBoolean
  • AtomicInteger
  • AtomicLong

源码分析(实现原理)

以AutomicInteger为例,分析源码

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

	//offset,value的偏移量,用来计算CAS中的V
    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    //成员变量value声明为volatile类型,说明了多线程下的可见性,即任何一个线程的修改,在其它线程中都会被立刻看到
    private volatile int value;

    public AtomicInteger(int initialValue) {
        value = initialValue;
    }

    public AtomicInteger() {
    }

    public final int get() {
        return value;
    }

    public final void set(int newValue) {
        value = newValue;
    }

    public final void lazySet(int newValue) {
        unsafe.putOrderedInt(this, valueOffset, newValue);
    }
    
	//获取当前值,set新值,通过调用unsafe的getAndSetInt方法
    public final int getAndSet(int newValue) {
        return unsafe.getAndSetInt(this, valueOffset, newValue);
    }

	//没看出来和下一个方法有什么区别,成功后返回期望值
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

    public final boolean weakCompareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

	//先get,然后自增
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }
    
    //先get,然后自减
    public final int getAndDecrement() {
        return unsafe.getAndAddInt(this, valueOffset, -1);
    }

	//先get,然后add,与上几个方法类似,调用unsafe.getAndInt
    public final int getAndAdd(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta);
    }

	//与之前方法相反,注意返回值,实现的很巧妙
    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }

    public final int decrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
    }

    public final int addAndGet(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
    }

	//顾名思义,先获取值再更新。直到CAS成功,返回prev
    public final int getAndUpdate(IntUnaryOperator updateFunction) {
        int prev, next;
        do {
            prev = get();
            next = updateFunction.applyAsInt(prev);
        } while (!compareAndSet(prev, next));
        return prev;
    }
    
    //与上面方法类似,返回值不同
    public final int updateAndGet(IntUnaryOperator updateFunction) {
        int prev, next;
        do {
            prev = get();
            next = updateFunction.applyAsInt(prev);
        } while (!compareAndSet(prev, next));
        return next;
    }

    public final int getAndAccumulate(int x,
                                      IntBinaryOperator accumulatorFunction) {
        int prev, next;
        do {
            prev = get();
            next = accumulatorFunction.applyAsInt(prev, x);
        } while (!compareAndSet(prev, next));
        return prev;
    }

    public final int accumulateAndGet(int x,
                                      IntBinaryOperator accumulatorFunction) {
        int prev, next;
        do {
            prev = get();
            next = accumulatorFunction.applyAsInt(prev, x);
        } while (!compareAndSet(prev, next));
        return next;
    }

    public String toString() {
        return Integer.toString(get());
    }
}

Usage

试用一下,下面的代码可以看出,经过多次运行,Demo的值都是100,可以比较充分地证明AtomicInteger是线程安全的。

package atomicClassUsage;


import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class Demo extends AtomicInteger implements Runnable{

    public Demo(int i){
        super(i);
    }

    @Override
    public void run() {
        this.addAndGet(1);
    }

    public static void main(String[] args) throws Exception {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(10,100,0, TimeUnit.SECONDS, new LinkedBlockingDeque<>());
        Demo demo = new Demo(0);
        for (int i = 0; i < 100; i++) {
            pool.execute(demo);
        }

        TimeUnit.SECONDS.sleep(1);
        System.out.println(demo.get());
    }
}

引用类型的原子类

源码分析(实现原理)

与基本类型类似,引用类型的原子类也是基于Unsafe类实现的。这里不做赘述

原子的updater

对字段更新的有AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdater

源码分析(实现原理)

下面以AtomicIntegerFieldUpdater为例介绍

public final int getAndSet(T obj, int newValue) {
            accessCheck(obj);
            return U.getAndSetInt(obj, offset, newValue);
        }

        public final int getAndAdd(T obj, int delta) {
            accessCheck(obj);
            return U.getAndAddInt(obj, offset, delta);
        }

以这两个方法为例,都是调用native方法实现,通过传入偏移量参数和新值进行CAS操作。

public static <U> AtomicIntegerFieldUpdater<U> newUpdater(Class<U> tclass,
                                                              String fieldName) {
        return new AtomicIntegerFieldUpdaterImpl<U>
            (tclass, fieldName, Reflection.getCallerClass());
    }

上面代码是构造方法,传入String类型的field是要进行反射吗?

AtomicIntegerFieldUpdaterImpl(final Class<T> tclass,
                                      final String fieldName,
                                      final Class<?> caller) {
            final Field field;
            final int modifiers;
            try {
                field = AccessController.doPrivileged(
                    new PrivilegedExceptionAction<Field>() {
                        public Field run() throws NoSuchFieldException {
                            return tclass.getDeclaredField(fieldName);
                        }
                    });
                modifiers = field.getModifiers();
                sun.reflect.misc.ReflectUtil.ensureMemberAccess(
                    caller, tclass, null, modifiers);
                ClassLoader cl = tclass.getClassLoader();
                ClassLoader ccl = caller.getClassLoader();
                if ((ccl != null) && (ccl != cl) &&
                    ((cl == null) || !isAncestor(cl, ccl))) {
                    sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
                }
            } catch (PrivilegedActionException pae) {
                throw new RuntimeException(pae.getException());
            } catch (Exception ex) {
                throw new RuntimeException(ex);
            }

可以看到,调用doPrivileged方法来拿到field;

public static native <T> T
        doPrivileged(PrivilegedExceptionAction<T> action)
        throws PrivilegedActionException;

这个方法是native的,与系统权限有关。上一段代码可以看出,field确实是通过反射得到的。对于更新的方法与前面类似,Unsafe实现,也不赘述了。

其他

没有说到的原子类有用于更新数组的,Double类型的,个人猜测用法和实现原理与前面提到的基本类似,原子类先了解到这吧,以后学到新的知识再来补充。