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 併發編程（五）原子操作類