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幾乎一致,在此不做分析

---