// 以原子方式將給定值添加到當(dāng)前值，然后將相加后的結(jié)果返回
public final int addAndGet(int delta){}
// 指定期望值與修改后的值，如果期望值和當(dāng)前值相同則進(jìn)行更新操作
public final boolean compareAndSet(int expect, int update) {}
// 先返回當(dāng)前值，然后再進(jìn)行原子自增1
public final int getAndIncrement() {}
// 先返回當(dāng)前值，然后進(jìn)行原子更新操作
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){}
// 先比較，期望值和當(dāng)前值相同再執(zhí)行更新操作
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));
        //原數(shù)組不會(huì)變化
        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) {
        //要修改的實(shí)體的實(shí)例
        UserInfo user = new UserInfo("Mark", 15);
        atomicUserRef = new AtomicReference(user);
        // 再創(chuàng)建一個(gè)對象
        UserInfo updateUser = new UserInfo("Bill",17);
        // 期望值和當(dāng)前值相同就進(jìn)行修改
        atomicUserRef.compareAndSet(user,updateUser);
        System.out.println(atomicUserRef.get());
        System.out.println(user);
        /*
        	輸出結(jié)果：
            UserInfo{name='Bill', age=17}
            UserInfo{name='Mark', age=15}
		*/
    }
    /**
     * 定義一個(gè)實(shí)體類
     */
    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 +
                    '}';
        }
    }
}

// 第二個(gè)線程，期望的時(shí)間戳和當(dāng)前時(shí)間戳不同，所以更新不成功
public class UseAtomicStampedReference {
    static AtomicStampedReference<String> asr = new AtomicStampedReference("mark", 0);
    public static void main(String[] args) throws InterruptedException {
        //拿到當(dāng)前的版本號(hào)(舊)
        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() + ":當(dāng)前變量值："
                        + oldReference + "-當(dāng)前版本戳：" + 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() + ":當(dāng)前變量值："
                        + reference + "-當(dāng)前版本戳：" + 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());
    }
}

// 當(dāng)為非空時(shí)，大小為 2 的冪。
// 如果并發(fā)很高就使用cell數(shù)組做寫熱點(diǎn)的分散，其中某些線程共同操作某一個(gè)數(shù)組中的元素
transient volatile Cell[] cells;
// 當(dāng)爭搶較少時(shí)使用這個(gè)變量來進(jìn)行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;
}