JDK源码——java.util.concurrent

 最近一直在忙各种乱七八糟的事,好久没写博客了,前两天以为要研究多线程的问题,所以把很多j.u.c包中的类的源码看了看,感觉收获了很多,下面给大家分享分享

---

 首先分析几个比较简单也比较类似的类AtomicBoolean、AtomicInteger、AtomicLong,这几个都是线程安全的原始类型封装类,看看如何使用

public class AtomicIntegerTest {
    static class AutoTest{
        AtomicInteger atomicInteger = new AtomicInteger(0);
        int b = 0;
        public  int atomicIntegerAdd(){
            return atomicInteger.incrementAndGet();
        }

        public int getAtomic(){
            return atomicInteger.get();
        }

        public  int bAdd(){
            return b++;
        }

        public  int getB(){
            return b;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        final AutoTest autoTest = new AutoTest();
        for (int i = 0; i < 100; i++) {
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 100; j++) {
                        autoTest.atomicIntegerAdd();
                        autoTest.bAdd();
                    }
                }
            };
            Thread thread = new Thread(runnable);
            thread.start();
        }

        TimeUnit.SECONDS.sleep(10);

        System.out.println(autoTest.getB());//9996
        System.out.println(autoTest.getAtomic());//10000

    }
}

由上面的结果可知AtomicInteger可以线程安全的自增,那这个是怎么实现的呢?咱们来看看它的源码,其主要属性如下

    //unsafe类可直接操作内存.后面的cas都是通过unsafe来操作  
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    //保存value变量在内存中偏移量地址
    private static final long valueOffset;
    //实例化变量时获取偏移量地址
    static {
      try {
        valueOffset = unsafe.objectFieldOffset
            (AtomicInteger.class.getDeclaredField("value"));
      } catch (Exception ex) { throw new Error(ex); }
    }
    //volatile类型变量，保证value的可见性，原子性通过unsafe的cas操作来保证
    private volatile int value;

ps.这里有一个比较关键的点,volatile关键字,volatile关键字保证变量的可见性、防止指令重新排序,但它是如何保证可见性的呢?用volatile关键字修饰的变量不会放在寄存器中,而是放在主内存中,因此多个线程访问时保证其可见性(即不放在栈中,而放在堆中).

咱们来看看其中比较关键的几个方法

/** 
直接设置volatile变量的值 
*/ 
public final void set(int newValue) {
        value = newValue;
    }
/** 
这个其实不是很理解是什么意思,网上搜到说法如下
putOrderedInt,去掉了storeLoad内存屏障,只保证最终设置成功，不保证多处理环境下，其他处理器read到最新的值 
*/
public final void lazySet(int newValue) {
        unsafe.putOrderedInt(this, valueOffset, newValue);
    }
/**
不断循环以cas方式赋值,直到成功为止
*/
public final int getAndSet(int newValue) {
        for (;;) {
            int current = get();
            if (compareAndSet(current, newValue))
                return current;
        }
    }

/**
调用unsafe类的compareAndSwapInt实现cas操作
*/
public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

AtomicBoolean、AtomicLong的源码与AtomicInteger十分相似,这里就不列出了;这三个类其实都很简单,难的是理解Unsafe类的cas操作,但这个我也并不能说的十分清楚.

除了上述三个对基本类型的原子操作外,还有提供对引用类型的原子操作:AtomicReference,其用法、源码与基本类型原子操作基本一致,我这里不做分析

---

AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray三个类分别是int型数组、long型数组、引用类型数组的原子操作类,结构与其基本类型操作十分相似,在此不做分析

---

AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdater提供了对某个类中特定类型属性的原子操作;以AtomicIntegerFieldUpdater为例:

package com.kevindai.juc;

import sun.reflect.Reflection;

import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

public class AtomicIntegerFieldUpdaterTest {
    static class AtomicFieldIncr {

        //这里最好是public volatile，不要加final、static
        //修饰符最好也不要为protected，private，涉及调用者访问被调用者的access问题
        public volatile int idx;

        public AtomicFieldIncr(){
        }

        public int getIdx(){
            return this.idx;
        }

        public void setIdx(int idx){
            this.idx = idx;
        }
    }

    public static void main(String[] args) {
        AtomicFieldIncr atomicFieldIncr = new AtomicFieldIncr();
        AtomicIntegerFieldUpdater<AtomicFieldIncr> atomicFieldUpdater = AtomicIntegerFieldUpdater.newUpdater(AtomicFieldIncr.class , "idx");

        atomicFieldUpdater.set(atomicFieldIncr, 3);
        System.out.println(atomicFieldIncr.getIdx());

        atomicFieldUpdater.compareAndSet(atomicFieldIncr, 3, 4);
        System.out.println(atomicFieldIncr.getIdx());
    }
}

AtomicIntegerFieldUpdater本身为abstract，内部提供static实现AtomicIntegerFieldUpdaterImpl，看下AtomicIntegerFieldUpdater的构造函数：

/**
tclass就是被调用类，也就是需要变量原子操作的类 
fieldName：tclass中volatile变量
*/
@CallerSensitive
    public static <U> AtomicIntegerFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName) {
    //Reflection.getCallerClass()获取我们的调用类,使用反射机制
        return new AtomicIntegerFieldUpdaterImpl<U>(tclass, fieldName, Reflection.getCallerClass());
    }

AtomicIntegerFieldUpdater定义了一些抽象方法,跟普通AtomicInteger一样，看下AtomicIntegerFieldUpdaterImpl的构造函数:

AtomicIntegerFieldUpdaterImpl(Class<T> tclass, String fieldName, Class<?> caller) {
            Field field = null;
            int modifiers = 0;
            try {
                //反射获取字段
                field = tclass.getDeclaredField(fieldName);
                modifiers = field.getModifiers();
                //校验volatile变量的访问权限  
                //被调用者类中的volatile变量一般定义成public volatile不会有问题，如果是其他需要注意sun.reflect.misc.ReflectUtil.ensureMemberAccess(
                    caller, tclass, null, modifiers);
                sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
            } catch (Exception ex) {
                throw new RuntimeException(ex);
            }
            //检查字段类型
            Class fieldt = field.getType();
            if (fieldt != int.class)
                throw new IllegalArgumentException("Must be integer type");
            //检查字段是否为volatile
            if (!Modifier.isVolatile(modifiers))
                throw new IllegalArgumentException("Must be volatile type");

            this.cclass = (Modifier.isProtected(modifiers) &&
                           caller != tclass) ? caller : null;
            this.tclass = tclass;
            offset = unsafe.objectFieldOffset(field);
        }

这里最主要是检查字段权限,绝对不要定义成static/final，修饰符的问题还是看权限
实现类中的具体操作,大概流程都一样,先做校验,主要是校验你传入的类是否跟之前保存的被调用的类型一致,然后再调用unsafe的底层操作,代码很简单,我简单列出一下:

private void fullCheck(T obj) {
            if (!tclass.isInstance(obj))
                throw new ClassCastException();
            if (cclass != null)
                ensureProtectedAccess(obj);
        }

        public boolean compareAndSet(T obj, int expect, int update) {
            if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
            return unsafe.compareAndSwapInt(obj, offset, expect, update);
        }

        public boolean weakCompareAndSet(T obj, int expect, int update) {
            if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
            return unsafe.compareAndSwapInt(obj, offset, expect, update);
        }

        public void set(T obj, int newValue) {
            if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
            unsafe.putIntVolatile(obj, offset, newValue);
        }

        public void lazySet(T obj, int newValue) {
            if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
            unsafe.putOrderedInt(obj, offset, newValue);
        }

        public final int get(T obj) {
            if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
            return unsafe.getIntVolatile(obj, offset);
        }

        private void ensureProtectedAccess(T obj) {
            if (cclass.isInstance(obj)) {
                return;
            }
            throw new RuntimeException(
                new IllegalAccessException("Class " +
                    cclass.getName() +
                    " can not access a protected member of class " +
                    tclass.getName() +
                    " using an instance of " +
                    obj.getClass().getName()
                )
            );
        }

---

下面来看看解决CAS的ABA问题的一个类AtomicStampedReference,首先来看看如何使用:

public class AtomicStampedReferenceTest {

    private static AtomicStampedReference<Integer> atomicStampedRef = new AtomicStampedReference<Integer>(100, 0);
    public static void main(String[] args) {
        Thread refT1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                atomicStampedRef.compareAndSet(100, 101, atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);
                atomicStampedRef.compareAndSet(101, 100, atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);
            }
        });

        Thread refT2 = new Thread(new Runnable() {
            @Override
            public void run() {
                int stamp = atomicStampedRef.getStamp();
                System.out.println("before sleep: stamp = " + stamp);
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("after sleep: stamp = " + atomicStampedRef.getStamp());
                boolean c3 = atomicStampedRef.compareAndSet(100, 101, stamp, stamp + 1);
                System.out.println(c3); // false, 设置失败了，因为戳“stamp”的检查未通过
            }
        });

        refT1.start();
        refT2.start();
    }
}

由上面的例子咱们可以知道,使用AtomicStampedReference时不仅要设置引用还要设置计数器,如果计数器不满足条件设值也会失败,下面咱们看看其是如何实现的:

/** 
通过static pair保存一个引用和计数器,引用和计数器均为final
*/
private static class Pair<T> {
        final T reference;
        final int stamp;
        private Pair(T reference, int stamp) {
            this.reference = reference;
            this.stamp = stamp;
        }
        static <T> Pair<T> of(T reference, int stamp) {
            return new Pair<T>(reference, stamp);
        }
    }

    private volatile Pair<V> pair;
    /**
    通过传入的初始化引用和计数器来构造函数一个pair
    */
    public AtomicStampedReference(V initialRef, int initialStamp) {
        pair = Pair.of(initialRef, initialStamp);
    }

public boolean compareAndSet(V   expectedReference,
                                 V   newReference,
                                 int expectedStamp,
                                 int newStamp) {
        Pair<V> current = pair;
        //每次操作前不但比较引用值还比较计数器，底层还是调用 Unsafe的方法
        return
            expectedReference == current.reference &&
            expectedStamp == current.stamp &&
            ((newReference == current.reference &&
              newStamp == current.stamp) ||
             casPair(current, Pair.of(newReference, newStamp)));
    }

    private boolean casPair(Pair<V> cmp, Pair<V> val) {
        return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
    }

还有一些获取引用和计数器的方法我就不列出了;AtomicStampedReference主要是在其内部有一个Pairs对象用于保存引用和计数器,当进行赋值是,不仅要比较引用,还要比较计数器.
AtomicMarkableReference与AtomicStampedReference几乎一致,在此不做分析

---