incrementAndGet是如何实现线程安全的

我们先来看一下线程安全性的定义.
定义:当多个线程访问某个类时.不管运行时环境采用何种调度方式或者这些进程将如何交替执行
,并且在主调代码中不需要任何额外的同步或协同,这个类都能表现出正确的行为,那么就称这个类是线程安全的

线程安全主要体现在三个方面:

• 原子性:提供了互斥访问,同一时刻只能有一个线程来对它进行操作

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

• 有序性:一个线程观察其他线程中的指令执行顺序,由于指令重排序的存在,该观察结果一般会杂乱无章

我们今天主要来看原子性它是如何做到同一时刻只能有一个线程来对它进行操作的
提起原子性不得不介绍在jdk里提供的Atomic包

在以往的学习中,我们发现在不做线程同步的情况下,在高并发情况下进行计数器++会得不到我们想要的结果.所以我们今天来结合源码看看Atomic包是如何来给我们实现线程安全的.

我们先来看一个演示类

package com.imooc.concurrency.example.count;

import com.imooc.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;

/**
 * @Author zty
 * @Date 2020/3/9 下午6:45
 * @Description:
 */
@Slf4j
@ThreadSafe
public class CountExample2 {
    //请求总数
    public static int cilentTotal = 5000;

    //同时并发执行的线程数
    public static int threadTotal = 200;
    //这里要注意,不要使用int 要使用Atomic提供的类
    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(cilentTotal);
        for (int i = 0; i < cilentTotal; i++){
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    add();
                    semaphore.release();
                } catch (InterruptedException e) {
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("count:{}",count.get());
    }

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

这是一个线程安全的计数器.
我们先介绍一下incrementAndGet和getAndIncrement的区别
两个方法处理的方式都是一样的,意思都是在当前值基础上+1，区别在于

getAndIncrement

方法是返回旧值（即加1前的原始值），而

incrementAndGet

返回的是新值（即加1后的值）

我们今天主要来看incrementAndGet方法是如何实现线程安全的

源码分析

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

在这个incrementAndGet里,我们可以看到使用了一个unsafe的类
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;
    }

我们来具体看一下他的实现,通过一个do while语句来做一个主体实现的
在while语句里核心调了一个方法叫做mpareAndSwapInt
我们打开看看它的实现

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

这是一个native标注的方法,这个代表是java底层的代码,不是我们通过java语句去实现的代码.

回过头来 我们继续看看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;
    }

首先我们传过来的第一个值是当前的对象,比如说我们案例代码里的count,第二个值是我们当前的值(比如如果我们要实现2+1)那么var2 就是2 var4就是1
这里的var5,它是我们调用底层的方法var5 = this.getIntVolatile(var1, var2);获取底层当前的值
如果没有其他线程来处理count这个变量的时候,它的正常返回值应该是2,因此传到compareAndSwapInt的参数就是(count,2,2,2+1),这个方法想达到的目标就是对于count这个对象,如果当前的这个值和底层的这个值相等的情况下,就把它更新成后面那个值var5+var4

当我们一个方法进来的时候,我们var2的值是2,我们第一次取出来var5的值也等于2,但是当我们在执行更新成3的时候 也就是这句代码

while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

可能会被其它线程更改,所以我们要判断var2 是否与var5是相同的,只有是相同的,才允许它更新为3

通过这样不停的循环来判断,就能保证期望的值和底层的值相同

CAS比较与交换的伪代码可以表示为：

do{

备份旧数据；

基于旧数据构造新数据；

}while(!CAS( 内存地址，备份的旧数据，新数据 ))

Java中的乐观锁大部分都是基于CAS（Compare And Swap，比较和交换）操作实现的，CAS设一种原子操作，在对数据操作之前，首先会比较当前值跟传入值是否一样，如果一样咋更新，否则不执行更新操作直接返回失败状态。
compareAndSwapInt也是CAS的核心