线程安全-AtomicInteger

定义：当多个线程访问某个类时，不管运行时环境采用 何种调度方式

或者这些进程将如何交替执行，并且在主调代码中 不需要任何额外的

同步或协同，这个类都能表现出 正确的行为，那么就称这个类是线程安全的。

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

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

有序性：一个 线程观察其他线程中的指令执行顺序，由于指令重排序的存在

该观察结果一般杂乱无序。

原子性-atmotic包

package com.mmall.concurrency.example.atomic;

import com.mmall.concurrency.annoations.ThreadSafe;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;

@Slf4j
@ThreadSafe
public class AtomicExample1 {

    // 请求总数
    public static int clientTotal = 5000;

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

    public static AtomicInteger count = new AtomicInteger(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);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("count:{}", count.get());
    }

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

  count.incrementAndGet();

注意上面代码：看源码

 /**
     * Atomically increments by one the current value.
     *
     * @return the updated value
     */
    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }

关键点：使用了unsafe的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;
    }

解释：当前的值var2和底层的值var5作对比，如果值一样的话才进行操作var5+var4

compareAndSwapInt是java底层的方法

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

native表示java底层的方法