AtomicInteger如何保证原子性

线程安全性：当多个线程访问某个类时，不管运行时环境采取何种调度方式，或者这些线程将如何调度执行，并且在主调代码中不需要任何额外的同步或协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的；

线程安全体现在三个方面：

有序性：提供了互斥访问，同一时刻只能有一个线程对它进行操作；

可见性：一个线程对主内存的修改可以及时的被其它线程观察到；

原子性：提供了互斥访问，同一时刻只能有一个线程对它进行操作；

示例

package com.keytech.task;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.LongAdder;

/**
 * @className: AtomicTest
 * @description: TODO 类描述
 * @author: mac
 * @date: 2020/12/27
 **/
public class AtomicTest {

    private static Integer clientTotal=5000;
    private static Integer threadTotal=200;

    private static AtomicInteger count=new AtomicInteger(0);

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        Semaphore semaphore= new Semaphore(threadTotal);
        for (int i = 0; i <clienttotal ; i++) { executorservice.execute(()->{
                try{
                    semaphore.acquire();
                    update();
                    semaphore.release();
                }catch (Exception e){
                    e.printStackTrace();
                }
            });
        }
        executorService.shutdown();
        System.out.println("count:"+count);
    }

    private static void update(){
        count.incrementAndGet();
    }
}

public final int incrementAndGet() {
        return U.getAndAddInt(this, VALUE, 1) + 1;
    }

getAndAddInt源码

public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
}

AtomicInteger的原理是依靠底层的cas来保障原子性的更新数据，在要添加或者减少的时候，会使用死循环不断地cas到特定的值，从而达到更新数据的目的。