非阻塞同步 同步与阻塞 浅析从同步原语看非阻塞同步以及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
    }
}