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());
}
}
喜欢的话记得点个赞
版权声明：本文不是「本站」原创文章，版权归原作者所有 | 原文地址: