13、Java并发实战:JUC下原子变量操作类AtomicLong源码分析

JAVA并发编程(十三)JUC下原子变量操作类AtomicLong源码分析

  • JAVA并发编程(十三)JUC下原子变量操作类AtomicLong源码分析
    • 1.1 什么是原子变量操作类?
  • 1.2 AtomicLong源码分析
    • 1.2.1递增递减操作
    • 1.2.2 boolean comapreAndSet(long expect , long update)方法
    • 1.2.3 简单应用实例

JAVA并发编程(十三)JUC下原子变量操作类AtomicLong源码分析

1.1 什么是原子变量操作类?

要想理解这个概念,我们先来理解一下什么是原子操作和原子变量。

原子操作是指不会被线程调度机制打断的操作;原子操作一旦开始,就一直运行到结束,中间不会切换到任何别的进程。
原子变量是原子操作的基本单位。而我们原子变量操作类,提供了很多方法供我们操作原子变量

JUC这个包给我们提供了一系列的原子变量操作类,这些类都是使用非阻塞算法CAS实现的,相比用锁实现原子性操作这在性能上有很大的提升。由于原子变量操作类他们内部的原理都是一样的,所以我就不一一讲述了,只挑一个最简单的AtomicLong这个类,其他的都大同小异。

1.2 AtomicLong源码分析

我们知道JUC并发包中含有AtomicInteger、AtomicLong和AtomicBoolean等原子性操作类,他们的内部原理都是相似,这里我着重介绍AtomicLong这个类。

话不多说,先看源码(Talk is cheap , show me the code),这里的源码我简化了一下。

public class AtomicLong extends Number implements java.io.Serializable {
   
     
    private static final long serialVersionUID = 1927816293512124184L;

 	//获取Unsafe实例(因为之后要做一些底层操作)
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    //如果之前有看过我CAS的那一篇博客,对这个应该不陌生
    //这个是存放value的偏移量
    private static final long valueOffset;
    //判断一下JVM是否支持Long类型的无锁CAS
    static final boolean VM_SUPPORTS_LONG_CAS = VMSupportsCS8();
   
    private static native boolean VMSupportsCS8();

    static {
   
     
        try {
   
     
            //获取value在AtomicLong这个的偏移量
            valueOffset = unsafe.objectFieldOffset
                (AtomicLong.class.getDeclaredField("value"));
        } catch (Exception ex) {
   
      throw new Error(ex); }
    }
	//实际value变量
    private volatile long value;
   
    //有参构造器,初始化value的值
    public AtomicLong(long initialValue) {
   
     
        value = initialValue;
    }

    public AtomicLong() {
   
     
    }
}

看了上面代码以后,我觉得你应该会有两个问题,为什么value被声明为volatile,为什么这个类可以直接这样Unsafe.getUnsafe();获得Unsafe实例。

咱们一个一个来解答,value被声明为volatile的原因是:为了在多线程下保证内存可见性,value是具体存放计数的变量。他希望每一个线程都可见。可以使用getUnsafe()直接获得的原因是:是因为这个类是在rt.jar包下,所以他是用的BootStrap类加载器加载的。

1.2.1递增递减操作

那么接下来我们来看看递增或者递减操作的源码把:

//调用Unsafe的方法,原子性设置value的值+1,并返回递增后的值
public final long incrementAndGet() {
   
     
     return unsafe.getAndAddLong(this, valueOffset, 1L) + 1L;
 }

//调用Unsafe的方法,原子性设置value的值-1,并返回递减后的值
public final long decrementAndGet() {
   
     
    return unsafe.getAndAddLong(this, valueOffset, -1L) - 1L;
}

//调用Unsafe的方法,原子性设置value的值+1,并返回原始的值
public final long getAndIncrement() {
   
     
    return unsafe.getAndAddLong(this, valueOffset, 1L);
}

//调用Unsafe的方法,原子性设置value的值-1,并返回原始的值
public final long getAndDecrement() {
   
     
    return unsafe.getAndAddLong(this, valueOffset, -1L);
}

上面代码的getAndAddLong(this,valueOffset,-1L)这个方法,在也就是获得value,然后-1,只不过保证了原子性。

从上面的源码可以看出,AtomicLong保证原子性还是使用的Unsafe类的CAS方法,尤其可见Unsafe的重要性。

上面的源码是jdk8的源码,而jdk7的getAndIncrement()方法有不同了

public final long getAndIncrement(){
    while(true){
        long current = get();
        long next = current + 1;
        if(compareAndSet(current , next)){
            return current;
        }
    }
}

如上代码,每个线程先是拿到变量的当前值(由于value是volatile变量,所以这里拿到的是最新的值),然后再线程本地内存中对其进行+1操作,而后使用CAS操作修改变量的值,如果设置失效,则循环设置,直到设置成功。

那为什么jdk7的代码里面有这个循环,而jdk8没有呢?因为jdk8使用Unsafe类来进行设置,这个循环工作被放到了Unsafe类的getAndAddLong方法里面,因为考虑到其他的方法也会用到,干脆集成到Unsafe里面

public final long getAndAddLong(Object var1, long var2, long var4) {
   
     
    long var6;
    do {
   
     
        var6 = this.getLongVolatile(var1, var2);
    } while(!this.compareAndSwapLong(var1, var2, var6, var6 + var4));

    return var6;
}

1.2.2 boolean comapreAndSet(long expect , long update)方法

 public final boolean weakCompareAndSet(long expect, long update) {
   
     
     return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
 }

由上代码我们还是可以知道,这个方法内部调用的还是Unsafe的compareAndSwapLong,如果原子变量中的value值等于expect,则使用update的值更新value并返回true,否则返回false。

1.2.3 简单应用实例

下面是一个多线程使用AtomicLong类的例子,可以帮助你更快理解。

public class AtomicLongDemo {
   
     
    private static AtomicLong atomicLong = new AtomicLong();
    private static Integer[] arrayOne = new Integer[]{
   
     0,1,2,3,0,5,6,7,0,9};
    private static Integer[] arrayTwo = new Integer[]{
   
     10,51,21,30,40,0,67,75,0,49};
    public static void main(String[] args) throws InterruptedException {
   
     
        //线程one统计arrayOne里面的0的数量
        Thread threadOne = new Thread(new Runnable() {
   
     
            @Override
            public void run() {
   
     
               int size = arrayOne.length;
               for(int i = 0 ; i < size ; ++i){
   
     
                   if(arrayOne[i].intValue() == 0){
   
     
                       atomicLong.incrementAndGet();
                   }
               }
            }
        });

        //线程two统计arrayOne里面的0的数量
        Thread threadTwo = new Thread(new Runnable() {
   
     
            @Override
            public void run() {
   
     
                int size = arrayTwo.length;
                for(int i = 0 ; i < size ; ++i){
   
     
                    if(arrayTwo[i].intValue() == 0){
   
     
                        atomicLong.incrementAndGet();
                    }
                }
            }
        });

        //启动线程
        threadOne.start();
        threadTwo.start();

        //等待线程执行完毕
        threadOne.join();
        threadTwo.join();

        System.out.println("count 0:"+atomicLong.get());
    }
}

喜欢的话记得点个赞

版权声明:本文不是「本站」原创文章,版权归原作者所有 | 原文地址: