public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);

public native long staticFieldOffset(Field var1);

public native long objectFieldOffset(Field var1);

do{
	获取字段的期望值(oldValue);
    计算出需要替换的新值(newValue);
} while(!CAS(内存地址,oldValue,newValue))

package com.fly.cas;

import sun.misc.Unsafe;

import java.lang.reflect.Field;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;

public class CASExample01 {

    // 并发数量
    private static final int THREAD_COUNT = 10;
    // 每次累加值
    private static final int INCREMENT_COUNT = 1000;

    public static void main(String[] args) throws InterruptedException {
        final OptimisticLockPlus cas = new OptimisticLockPlus();
        // 倒数闩,需要倒数 THREAD_COUNT 次,await()才会停止阻塞
        CountDownLatch latch = new CountDownLatch(THREAD_COUNT);
        // 通过Executors线程池工厂快捷创建一个具有缓存功能的线程池(不推荐)
        ExecutorService pool = Executors.newCachedThreadPool();
        for (int i = 0; i < THREAD_COUNT; i++) {
            // 提交10个任务
            pool.submit(() -> {
                for (int j = 0; j < INCREMENT_COUNT; j++) {
                    cas.increment();
                }
                // 每执行完一个任务,计数闩就倒数减一
                latch.countDown();
            });
        }
        // 主线程阻塞等待计数闩倒数完毕
        latch.await();
        // 关闭线程池
        pool.shutdown();
        System.out.println("累加和:" + cas.value);
        System.out.println("cas自旋次数:" + cas.failure.get());

    }

    static class OptimisticLockPlus {
        // 内部值,使用volatile关键字来保证线程的可见性
        private volatile int value;
        // value字段的偏移量
        private static long valueOffset = 0;
        // long类型的原子类,用于统计失败次数
        private final AtomicLong failure = new AtomicLong(0);
        // unsafe实例,通过unsafe提供的CAS方法来进行CAS操作
        private static final Unsafe unsafe = OptimisticLockPlus.getUnsafe();

        /**
         * 通过静态代码块初始化value字段的内存偏移量
         */
        static {
            try {
                // 获取value Field对象
                Field field = OptimisticLockPlus.class.getDeclaredField("value");
                field.setAccessible(true);
                // 获取value字段偏移量
                valueOffset = unsafe.objectFieldOffset(field);
            } catch (Exception e) {
                throw new Error(e);
            }
        }


        /**
         * 通过反射获取Unsafe实例
         *
         * @return Unsafe实例
         */
        public static Unsafe getUnsafe() {
            try {
                /**
                 * Unsafe类中提供了一个theUnsafe静态属性,通过
                 * Unsafe.class.getDeclaredField("theUnsafe")以反射机制获取Field对象,
                 * Field调用setAccessible()设置字段是可访问的,否则抛出NoSuchFieldException异常,
                 * 最后将Field强转为Unsafe对象
                 */
                Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
                theUnsafe.setAccessible(true);
                return (Unsafe) theUnsafe.get(null);
            } catch (Exception e) {
                throw new AssertionError(e);
            }
        }

        /**
         * 比较value字段的旧值与新值是否相等,若相等则将新值替换旧值
         *
         * @param oldValue 旧值
         * @param newValue 新值
         * @return
         */
        public final boolean unSafeCompareAndSet(int oldValue, int newValue) {
            return unsafe.compareAndSwapInt(this, valueOffset, oldValue, newValue);
        }

        // 自增方法
        public void increment() {
            // 获取旧值
            int oldValue = value;
            // 通过CAS自旋,如果操作失败就自旋,直到操作成功
            do {
                // 获取旧值
                oldValue = value;
                // 统计自旋次数
                failure.incrementAndGet();
            } while (!unSafeCompareAndSet(oldValue, oldValue + 1));
        }
    }
}

// 执行结果:
累加和:10000
cas自旋次数:20399