淺析從同步原語看非阻塞同步以及Java中的應用

lock(counterlock); //確保更新的原子性
if(count == 0) release = 0; //第一個進程到達，這時候重置release為0表示在其值變為1之前後續到達的進程都需要等待
count = count + 1; //記錄到達的進程數
unlock(counterlock); //釋放鎖
if(count == total) { //進程全部到達
    count = 0; //重置計數器count
    release = 1; //將release置為1表示釋放所欲到達的進程
} else { //進程還沒有全部到達
    spin(release == 1); //已經到達的進程旋轉等待知道所有的進程到達(言外之意就是release=1)
}

public class ThreadUnSafe{
    private Long value;

    public Long getValue() {return value;}

    public void increment() {++value;}
}

package test;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

public class TestAtomicStampedReference {

    static AtomicReference<Integer> atomicReference = new AtomicReference<>(1);

    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                atomicReference.compareAndSet(1,2);
                atomicReference.compareAndSet(2,1);
                System.out.println(Thread.currentThread() + "線程修改後的變量值" + atomicReference.get());
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                //sleep 1秒，保證線程t1完成1->2->1的模擬ABA操作
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                atomicReference.compareAndSet(1,3);
                System.out.println(Thread.currentThread() + "線程修改後的變量值" + atomicReference.get());
            }
        });

        t1.start();
        t2.start();
    }
}

package test;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;

public class TestAtomicStampedReference {

    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(10,1); //定義初始值和初始版本號
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                //線程1獲得初始版本號並sleep1秒
                int version = atomicStampedReference.getStamp();
                System.out.println(Thread.currentThread() + "當前線程獲得的版本號" + version);
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread() + "修改變量結果true/false?:" +
                        atomicStampedReference.compareAndSet(10,11,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1)
                        + "修改後的結果：" + atomicStampedReference.getReference());
                System.out.println(Thread.currentThread() + "修改變量結果true/false?:" +
                        atomicStampedReference.compareAndSet(11,10,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1)
                        + "修改後的結果：" + atomicStampedReference.getReference());
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                //首先獲得初始版本號，sleep2秒讓線程1完成10->11->10的模擬ABA操作
                int version = atomicStampedReference.getStamp();
                System.out.println(Thread.currentThread() + "當前線程獲得的版本號" + version);
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread() + "修改變量結果true/false?:" +
                        atomicStampedReference.compareAndSet(10,20,version,atomicStampedReference.getStamp()+1)
                        + "修改後的結果：" + atomicStampedReference.getReference());
            }
        });

        t1.start();
        t2.start();
    }
}

package test;

import sun.misc.Unsafe;

public class TestUnsafe {

    //獲取Unsafe的實例
    static Unsafe unsafe = Unsafe.getUnsafe();

    //記錄變量value在TestUnsafe中的偏移量
    static long valueState;

    //變量
    private volatile long value;

    static {
        try {
            //獲取value變量在TestUnsafe類中的偏移量
            valueState = unsafe.objectFieldOffset(TestUnsafe.class.getDeclaredField("value"));
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

    public static void main(String[] args) {
        TestUnsafe testUnsafe = new TestUnsafe();
        System.out.println(unsafe.compareAndSwapInt(testUnsafe,valueState,0,1));
    }
}

public static Unsafe getUnsafe() {
    //(1)獲取調用getUnsafe類的這個Class類，按照上面的程序中的TestUnsafa類
    Class var0 = Reflection.getCallerClass();
    //(2)看下面的那個方法
    if (!VM.isSystemDomainLoader(var0.getClassLoader())) {
        throw new SecurityException("Unsafe");
    } else {
        return theUnsafe;
    }
}
/**
 * (3)判斷是不是啟動類加載器加載的類，即看看是不是由BootStrapClassLoader加載的TestUnsafe.class，
 *    由於我們這是一個簡單測試類，是由應用程序類加載器AppClassLoader加載的,所以直接報出SecurityException異常
 */
public static boolean isSystemDomainLoader(ClassLoader var0) {
    return var0 == null;
}

package test;

import sun.misc.Unsafe;

import java.lang.reflect.Field;

public class TestUnsafe2 {

    static Unsafe unsafe;

    static long valueOffset;

    private volatile long value = 0;

    static {
        try {
            //使用反射獲取Unsafe的成員變量theUnsafe
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            //設置為課存取
            field.setAccessible(true);
            //設置該變量的值
            unsafe = (Unsafe) field.get(null);
            //獲取value偏移量
            valueOffset = unsafe.objectFieldOffset(TestUnsafe2.class.getDeclaredField("value"));
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        TestUnsafe2 test = new TestUnsafe2();
        System.out.println("修改變量結果true/false?:" +
                unsafe.compareAndSwapInt(test,valueOffset,0,1)
                + "修改後的結果：" + test.value);
    }
}

public class AtomicLong extends Number implements java.io.Serializable {

    //(1)獲取Unsafe實例
    private static final Unsafe unsafe = Unsafe.getUnsafe();

    //(2)保存value值的偏移量
    private static final long valueOffset;

    //(3)判斷當前JVM是否支持Long類型的無鎖CAS
    static final boolean VM_SUPPORTS_LONG_CAS = VMSupportsCS8();
    private static native boolean VMSupportsCS8();

    static {
        try {
            //(4)獲取value值在AtomicLong中的偏移量
            valueOffset = unsafe.objectFieldOffset
                (AtomicLong.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    //(5)實際存的變量值value
    private volatile long value;

    //構造方法
    public AtomicLong(long initialValue) {
        value = initialValue;
    }
}

//使用unsafe的方法，原子性的設置value值為原始值+1，返回值為遞增之後的值
public final long getAndIncrement() {
    return unsafe.getAndAddLong(this, valueOffset, 1L);
}
public final long incrementAndGet() {
    return unsafe.getAndAddLong(this, valueOffset, 1L) + 1L;
}
//使用unsafe的方法，原子性的設置value值為原始值-1，返回值為遞減之後的值
public final long getAndDecrement() {
    return unsafe.getAndAddLong(this, valueOffset, -1L);
}
public final long decrementAndGet() {
    return unsafe.getAndAddLong(this, valueOffset, -1L) - 1L;
}

public final long getAndAddLong(Object var1, long var2, long var4) {
    long var6;
    do {
        //public native long getLongVolatile(Object var1, long var2);
        //該方法就是獲取var1引用指向的內存地址中偏移量為var2位置的值，然後賦給var6
        var6 = this.getLongVolatile(var1, var2);
    /**public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
     * var1:AtomicXXX類型的一個引用，指向堆內存中的一塊地址
     * var2:AtomicXXX源碼中的valueOffset，表示AtomicXXX源碼中實際存儲的值value在原子類型內存中的地址偏移量
     * var4:要比較的目標值expectValue，如果從內存指定地址處(var1和var2決定的那塊地址)的值和該值相等，則CAS成功
     * var6:CAS成功後向該內存中寫進的新值
     */
    //該方法就是使用CAS的方式，比較指定內存地址處(var1指向的內存地址塊中偏移量為var2處)的值和上面同一塊地址處取出的var6是否相等，
    //相等就將var6+var4(這裡可以看成var6+1)和指定內存地址處(var2引用指向的地址塊中偏移量為var2處)的值交換，並返回true，然後就會結束循環
    //CAS失敗返回false，然後繼續執行循環體內部的代碼，直到成功(也就是自增運算成功就會跳出循環並返回自增後的值)
    } while(!this.compareAndSwapLong(var1, var2, var6, var6 + var4));

    return var6;
}

public final boolean compareAndSet(long expect, long update) {
    //public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
    return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
}

UNSAFE_ENTRY(jboolean,Usafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
UsafeWrapper("Usafe_CompareAndSwapInt");
oop p = JNIHasdles::resolve(obj);
jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
return (jint)(Atomic::cmpxchg(x,addr,e)) == e;
UNSAFE_END

package test;

import java.util.concurrent.atomic.AtomicLong;

public class TestAtomic1 {

    //創建AtomicLong類型的計數器
    private static AtomicLong atomicLong = new AtomicLong();
//    private static Long atomicLong = 0L;
    //創建兩個數組，計算數組中的0的個數
    private static Integer[] arr1 = {0,1,2,3,0,5,6,0,56,0};
    private static Integer[] arr2 = {10,1,2,3,0,5,6,0,56,0};

    public static void main(String[] args) throws InterruptedException {

        //線程1統計arr1中0的個數
        Thread t1  = new Thread(new Runnable() {
            @Override
            public void run() {
                int size = arr1.length;
                for (int i = 0; i < size; i++) {
                    if(arr1[i].intValue() == 0) {
//                        atomicLong.getAndIncrement();
                        atomicLong++;
                    }
                }
            }
        });

        Thread t2  = new Thread(new Runnable() {
            @Override
            public void run() {
                int size = arr2.length;
                for (int i = 0; i < size; i++) {
                    if(arr2[i].intValue() == 0) {
//                        atomicLong.getAndIncrement();
                        atomicLong++;
                    }
                }
            }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("兩個數組中0出現的次數為: " + atomicLong);//兩個數組中0出現的次數為: 7
    }
}