Java CAS与Atomic原子操作核心原理详解

// 以原子方式将给定值添加到当前值，然后将相加后的结果返回
public final int addAndGet(int delta){}
// 指定期望值与修改后的值，如果期望值和当前值相同则进行更新操作
public final boolean compareAndSet(int expect, int update) {}
// 先返回当前值，然后再进行原子自增1
public final int getAndIncrement() {}
// 先返回当前值，然后进行原子更新操作
public final int getAndSet(int newValue) {}

public class UseAtomicInt {
    static AtomicInteger ai = new AtomicInteger(10);
    public static void main(String[] args) {
        ai.getAndIncrement();
        ai.incrementAndGet();
        //ai.compareAndSet();
        ai.addAndGet(24);
    }
}

// 以原子方式将给定值添加到索引 i 处的元素。然后返回更新后的值
public final int addAndGet(int i, int delta){}
// 先比较，期望值和当前值相同再执行更新操作
public final boolean compareAndSet(int i, int expect, int update) {}

public class AtomicArray {
    static int[] value = new int[] { 1, 2 };
    static AtomicIntegerArray ai = new AtomicIntegerArray(value);
    public static void main(String[] args) {
        ai.getAndSet(0, 3);
        System.out.println(ai.get(0));
        //原数组不会变化
        System.out.println(value[0]);
        }
}
Process finished with exit code 0

public class UseAtomicReference {
    public static AtomicReference<UserInfo> atomicUserRef;
    public static void main(String[] args) {
        //要修改的实体的实例
        UserInfo user = new UserInfo("Mark", 15);
        atomicUserRef = new AtomicReference(user);
        // 再创建一个对象
        UserInfo updateUser = new UserInfo("Bill",17);
        // 期望值和当前值相同就进行修改
        atomicUserRef.compareAndSet(user,updateUser);
        System.out.println(atomicUserRef.get());
        System.out.println(user);
        /*
        	输出结果：
            UserInfo{name='Bill', age=17}
            UserInfo{name='Mark', age=15}
		*/
    }
    /**
     * 定义一个实体类
     */
    static class UserInfo {
        private volatile String name;
        private int age;
        public UserInfo(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public int getAge() {
            return age;
        }
        @Override
        public String toString() {
            return "UserInfo{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}

// 第二个线程，期望的时间戳和当前时间戳不同，所以更新不成功
public class UseAtomicStampedReference {
    static AtomicStampedReference<String> asr = new AtomicStampedReference("mark", 0);
    public static void main(String[] args) throws InterruptedException {
        //拿到当前的版本号(旧)
        final int oldStamp = asr.getStamp();
        final String oldReference = asr.getReference();
        System.out.println(oldReference + "============" + oldStamp);
        Thread rightStampThread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + ":当前变量值："
                        + oldReference + "-当前版本戳：" + oldStamp + "\n"
                        + asr.compareAndSet(oldReference, oldReference + "+Java", oldStamp, oldStamp + 1));
            }
        });
        Thread errorStampThread = new Thread(new Runnable() {
            @Override
            public void run() {
                String reference = asr.getReference();
                System.out.println(Thread.currentThread().getName() + ":当前变量值："
                        + reference + "-当前版本戳：" + asr.getStamp() + "\n"
                        + asr.compareAndSet(reference, reference + "+C", oldStamp, oldStamp + 1));
            }
        });
        rightStampThread.start();
        rightStampThread.join();
        errorStampThread.start();
        errorStampThread.join();
        System.out.println(asr.getReference() + "============" + asr.getStamp());
    }
}

// 当为非空时，大小为 2 的幂。
// 如果并发很高就使用cell数组做写热点的分散，其中某些线程共同操作某一个数组中的元素
transient volatile Cell[] cells;
// 当争抢较少时使用这个变量来进行cas，就类似于AtomicInteger类中的value变量
transient volatile long base;

// 可以看到 sum()方法没有任何加锁的逻辑
public long sum() {
    Cell[] as = cells;
    Cell a;
    long sum = base;
    if (as != null) {
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}