线程安全

线程安全测试：

@Slf4j
public class ConcurrencyTest {
    
    public static int clientTotal = 5000;//请求总数
    
    public static int threadTotal = 200;//允许并发线程数
    
    public static int count = 0;//
    
    public static void main(String[] args) throws Exception{
        //定义线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        //定义信号量
        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){
                    log.error("Exception--- " + e.getMessage());
                }
                countDownLatch.countDown();
                
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("count:{}" + count);
    }
    
    private static void add(){
        count++;
    }
}

线程安全性：

原子性：同一时刻只能有一个线程来操作。

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

有序性：

原子性 Atomic包：

public static AtomicInteger count = new AtomicInteger(0);//

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

incrementAndGet 实现：

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

unsafe.getAndAddInt(this, valueOffset, 1) 实现：

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;
}

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5); Java底层方法

当前值和底层的值相同，则更新值。
CAS：compareAndSwap

AtomicLong是作用是对长整形进行原子操作，显而易见，在java1.8中新加入了一个新的原子类LongAdder，该类也可以保证Long类型操作的原子性，相对于AtomicLong，
LongAdder有着更高的性能和更好的表现，可以完全替代AtomicLong的来进行原子操作。
在32位操作系统中，64位的long 和 double 变量由于会被JVM当作两个分离的32位来进行操作，所以不具有原子性。而使用AtomicLong能让long的操作保持原子型。

AtomicStampReference ： CAS的ABA问题

原子性对比：

synchronized：不可中断锁，适合竞争不激烈，可读性好；

Lock：可中断锁，多样化同步，竞争激烈时能维持常态；

Atomic：竞争激烈时能维持常态，比Lock性能好，只能同步一个值。

可见性：