Java原子操作类，你知道多少?

//著名的CAS
//var1是比较值所属的对象，var2需要比较的值（但实际是使用地址偏移量来实现的），
//如果var1对象中偏移量为var2处的值等于var4，那么将该处的值设置为var5并返回true，如果不等于var4则返回false。
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

AtomicBoolean //以原子更新的方式更新Boolean

AtomicIntege //以原子更新的方式更新Integer

AtomicLong //以原子更新的方式更新Long

addAndGet(int delta) //以原子方式将输入的数值与实例中原本的值相加，并返回最后的结果

incrementAndGet() //以原子的方式将实例中的原值进行加1操作，并返回最终相加后的结果

getAndSet(int newValue) //将实例中的值更新为新值，并返回旧值

getAndIncrement() //以原子的方式将实例中的原值加1，返回的是自增前的旧值

public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
}

private static final Unsafe unsafe = Unsafe.getUnsafe();
public class AtomicIntegerDemo {
    // 请求总数
    public static int clientTotal = 5000;

    // 同时并发执行的线程数
    public static int threadTotal = 200;

    //java.util.concurrent.atomic.AtomicInteger;
    public static AtomicInteger count = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        //Semaphore和CountDownLatch模拟并发
        final Semaphore semaphore = new Semaphore(threadTotal);
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        for (int i = 0; i < clientTotal ; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    add();
                    semaphore.release();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("count:{"+count.get()+"}");
    }

    public static void add() {
        count.incrementAndGet();
    }
}

count:{5000}

public final boolean compareAndSet(boolean expect, boolean update) {
    int e = expect ? 1 : 0;
    int u = update ? 1 : 0;
    return unsafe.compareAndSwapInt(this, valueOffset, e, u);
}

AtomicIntegerArray //原子更新整型数组中的元素

AtomicLongArray //原子更新长整型数组中的元素

AtomicReferenceArray //原子更新引用类型数组中的元素

getAndAdd(int i, int delta) //以原子更新的方式将数组中索引为i的元素与输入值相加

getAndIncrement(int i) //以原子更新的方式将数组中索引为i的元素自增加1

compareAndSet(int i, int expect, int update) //将数组中索引为i的位置的元素进行更新

public class AtomicIntegerArrayDemo {
    private static int[] value = new int[]{1, 2, 3};
    private static AtomicIntegerArray integerArray = new AtomicIntegerArray(value);

    public static void main(String[] args) {
        //对数组中索引为1的位置的元素加5
        int result = integerArray.getAndAdd(1, 5);
        System.out.println(integerArray.get(1));
        System.out.println(result);
    }
}

7
2

AtomicReference //原子更新引用类型

AtomicReferenceFieldUpdater //原子更新引用类型里的字段

AtomicMarkableReference //原子更新带有标记位的引用类型

public class AtomicReferenceDemo {

    private static AtomicReference<User> reference = new AtomicReference<>();

    public static void main(String[] args) {
        User user1 = new User("a", 1);
        reference.set(user1);
        User user2 = new User("b",2);
        User user = reference.getAndSet(user2);
        System.out.println(user);
        System.out.println(reference.get());
    }

    static class User {
        private String userName;
        private int age;

        public User(String userName, int age) {
            this.userName = userName;
            this.age = age;
        }

        @Override
        public String toString() {
            return "User{" +
                    "userName='" + userName + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}

User{userName='a', age=1}
User{userName='b', age=2}

AtomicIntegeFieldUpdater //原子更新整型字段类

AtomicLongFieldUpdater //原子更新长整型字段类

AtomicStampedReference //原子更新引用类型，这种更新方式会带有版本号。
// 而为什么在更新的时候会带有版本号，是为了解决CAS的ABA问题；

public class AtomicIntegerFieldUpdaterDemo {
    private static AtomicIntegerFieldUpdater updater =
        AtomicIntegerFieldUpdater.newUpdater(User.class,"age");
    
    public static void main(String[] args) {
        User user = new User("a", 1);
        int oldValue = updater.getAndAdd(user, 5);
        System.out.println(oldValue);
        System.out.println(updater.get(user));
    }

    static class User {
        private String userName;
        public volatile int age;

        public User(String userName, int age) {
            this.userName = userName;
            this.age = age;
        }

        @Override
        public String toString() {
            return "User{" +
                    "userName='" + userName + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}

1
6