Java 并发编程（五）原子操作类

Java 并发编程之原子操作类

Java从JDK1.5开始提供了Java.util.concurrent.atomic包,这个包中的原子操作类提供了一种用法简单,性能高效,线程安全地更新一个变量的方式.
接下来以AtomicInteger类为例进行分析.
Atomic包中的类基本都是使用Unsafe类来实现的,所以我们首先先来了解一下Unsafe类.

Unsafe部分源码分析

public final class Unsafe {
	...
	
/**
* 比较对象var1的var2处内存位置中的值和期望的值，如果相同则更新。此更新是不可中断的。
* 
* @param var1 需要更新的对象
* @param var2 var1中整型field的偏移量
* @param var4 希望field中存在的值
* @param var5 如果期望值var4与field的当前值相同，设置filed的值为这个新值var5
* @return 如果field的值被更改返回true
* /
    public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
}

compareAndSwapInt()为native方法,并不是通过Java实现的方法,是通过JNI调用操作系统中的原生程序来实现的,属于原子操作(具体原理自行查询).只需知道通过调用该方法可以实现CAS原子操作即可.

AtomicInteger主要方法介绍

public class AtomicInteger extends Number implements java.io.Serializable {
    public final int get() {
        return value;
    }
    public final void set(int newValue) {
        value = newValue;
    }
    public final int getAndSet(int newValue) {
        return unsafe.getAndSetInt(this, valueOffset, newValue);
    }

//如果输入的数值等于预期值,则将该值以原子方式设置为输入的值(update值)
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }
//以原子方式将当前值+1,返回自增前的值
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }
//以原子方式将当前值+1,返回更新后的值
    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }
}

AtomicInteger使用

之前文章中提到使用volatile来进行自增操作是线程不安全的操作.
下面给出一个Atomic包实现的线程安全的自增操作

class AtomicExample{
    private AtomicInteger atomicInt=new AtomicInteger();
    public void add(){
        atomicInt.getAndIncrement();
    }
    public int get(){
        return atomicInt.get();
    }
}

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        AtomicExample atomicExample = new AtomicExample();
        ExecutorService executorService = Executors.newCachedThreadPool();
        CountDownLatch countDownLatch = new CountDownLatch(1000);
        for (int i = 0; i <1000; i++) {
            executorService.execute(()->{
                atomicExample.add();
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println(atomicExample.get());
    }

代码运行结果:
1000

Java 并发编程（一）Volatile原理剖析及使用
Java 并发编程（二）Synchronized原理剖析及使用
Java 并发编程（三）Synchronized底层优化(偏向锁与轻量级锁)
Java 并发编程（四）JVM中锁的优化
Java 并发编程（五）原子操作类