cas demo

CAS.java

import sun.misc.Contended;
import sun.misc.Unsafe;

import java.lang.reflect.Field;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;

class Scratch {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        final CAS cas = new CAS();
        Runnable addFortyFive = () -> IntStream.range(0, 10).forEach(cas::addAndGet);
        IntStream.range(0, 100).forEach(x -> executorService.execute(addFortyFive));
        executorService.shutdown();
        executorService.awaitTermination(2, TimeUnit.SECONDS);

        System.out.println(cas.get());
        if (4500 != cas.get()) throw new AssertionError();
    }

    static class CAS {
        @Contended
        private volatile int x = 0;

        public int addAndGet(int n) {
            while (true) {
                int curr = get();
                int next = curr + n;
                if (compareAndSet(curr, next)) {
                    return next;
                }
            }
        }

        public int get() {
            return this.x;
        }

        private static final Unsafe unsafe;
        private static final long valueOffset;

        static {
            try {
                Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
                theUnsafe.setAccessible(true);
                unsafe = (Unsafe) theUnsafe.get(null);
                valueOffset = unsafe.objectFieldOffset(CAS.class.getDeclaredField("x"));
            } catch (Exception e) {
                throw new Error(e);
            }
        }

        private boolean compareAndSet(int expect, int update) {
            return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
        }
    }

}