线程安全性（一） 原子性 AtomicInteger

线程安全性

定义

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

线程安全体现在3个方面

• 原子性：提供了互斥访问，同一时刻只能有一个线程对它进行操作；
• 可见性：一个线程对主内存的修改可以及时的被其它线程观察到；
• 有序性：一个线程观察其它线程中指令的执行顺序，由于指令重拍的存在，观察结果一般杂乱无章；

AtomicInteger示例

示例程序描述

• 5000个线程要去修改count，每个线程把count加1，同时并发执行的线程数为200；
• 相当于5000个线程挤只有200个门的“葫芦口”，“葫芦口”的200个线程还要抢count的修改权；

AtomicInteger要点阐述

• AtomicInteger的实现是基于CAS（Compare And Swop）原理；
• AtomicInteger的语义是：对AtomicInteger中维护的int型变量的操作是原子性的；
• AtomicInteger实现的思想是：每个线程中都会拥有共享变量的一份私有拷贝，但由于多个线程都抢着操作共享变量，当前线程的私有拷贝已经不是共享变量的最新值；当前线程的私有拷贝只有和共享变量的最新值相等时，才能获得对共享变量的操作权利，这个操作是原子性的；当前线程的私有拷贝如何追上共享变量的最新值呢？就是在循环中不停的和共享变量最新值比，如果不相等，就把自己更新成最新值，再比，不等再更新，直到自己和最新值相等才获得了对共享变量的操作权；这套规则是AtomicInteger设计的，操作其维护的int值的线程遵守之；

示例程序要点阐述

• ExecutorService executorService = Executors.newCachedThreadPool(); 定义了一个线程池；
• final Semaphore semaphore = new Semaphore(threadTotal); 作为信号量，限制线程池中并发执行的线程数；
• final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); 倒计时控制器，每个线程都会把控制器的值减1；
• countDownLatch.await(); 会一直等到控制器的值减为0再执行其后代码；
• executorService.shutdown(); 线程池在最后需要关闭；

import com.example.concurrency.annotations.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 CountExample2 {

    // 请求总数
    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();
    }

}

AtomicInteger源码解析

• unsafe.getAndAddInt(this, valueOffset, 1) 这个方法执行完，this已经加1了，但其返回值是共享变量的最新值var5，故返回给调用处还得再加个1；

package java.util.concurrent.atomic;
public class AtomicInteger extends Number implements java.io.Serializable {
    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }
}

• var1 是线程对共享变量的私有拷贝；
• var4 是要给私有拷贝var1加上的值，但前提条件是：私有拷贝var1已经和共享变量的最新值相等了；
• var5 从主内存load回来的共享变量的最新值；
• 如果var1和var5相等了，就把var1更新成var5+var4；

package sun.misc;
public final class Unsafe {
    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;
    }
}

• var1 是线程对共享变量的私有拷贝；
• var4 共享变量的最新值；
• var5 var1更新后的值；
• 如果var1 == var4了，就把var1更新成var5；

package sun.misc;
public final class Unsafe {
    public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
}