[多线程系列]Java 中atomic包的解析

前言:

　　Java从JDK1.5开始提供了java.util.concurrent.atomic包，方便在多线程环境下进行原子操作。原子变量的底层使用了CPU提供的原子指令，但是不同的CPU架构可能提供的原子指令不一样，也有可能需要某种形式的内部锁,所以该方法不能绝对保证线程不被阻塞。

包介绍:

在atomic包里一共有12个类，四种原子更新方式，分别是原子更新基本类型，原子更新数组，原子更新引用和原子更新字段。Atomic包里的类基本都是使用Unsafe实现的包装类。

原子更新基本类型

• AtomicInteger
• AtomicLong
• AtomicBoolean

原子更新引用

• AtomicReference
• AtomicMarkableReference
• AtomicStampedReference 

原子更新数组

• AtomicIntegerArray
• AtomicLongArray
• AtomicReferenceArray

原子更新字段

• AtomicIntegerFieldUpdater
• AtomicLongFieldUpdater
• AtomicReferenceFieldUpdater

以下主要分析AtomicInteger,其他类大同小异

源码:

　　

/*
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

/*
 *
 *
 *
 *
 *
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */

package java.util.concurrent.atomic;
import sun.misc.Unsafe;

/**
 * An {@code int} value that may be updated atomically.  See the
 * {@link java.util.concurrent.atomic} package specification for
 * description of the properties of atomic variables. An
 * {@code AtomicInteger} is used in applications such as atomically
 * incremented counters, and cannot be used as a replacement for an
 * {@link java.lang.Integer}. However, this class does extend
 * {@code Number} to allow uniform access by tools and utilities that
 * deal with numerically-based classes.
 *
 * @since 1.5
 * @author Doug Lea
*/
public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
      try {
        valueOffset = unsafe.objectFieldOffset
            (AtomicInteger.class.getDeclaredField("value"));
      } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;

    /**
     * Creates a new AtomicInteger with the given initial value.
     *
     * @param initialValue the initial value
     */
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }

    /**
     * Creates a new AtomicInteger with initial value {@code 0}.
     */
    public AtomicInteger() {
    }

    /**
     * Gets the current value.
     *
     * @return the current value
     */
    public final int get() {
        return value;
    }

    /**
     * Sets to the given value.
     *
     * @param newValue the new value
     */
    public final void set(int newValue) {
        value = newValue;
    }

    /**
     * Eventually sets to the given value.
     *
     * @param newValue the new value
     * @since 1.6
     */
    public final void lazySet(int newValue) {
        unsafe.putOrderedInt(this, valueOffset, newValue);
    }

    /**
     * Atomically sets to the given value and returns the old value.
     *
     * @param newValue the new value
     * @return the previous value
     */
    public final int getAndSet(int newValue) {
        for (;;) {
            int current = get();
            if (compareAndSet(current, newValue))
                return current;
        }
    }

    /**
     * Atomically sets the value to the given updated value
     * if the current value {@code ==} the expected value.
     *
     * @param expect the expected value
     * @param update the new value
     * @return true if successful. False return indicates that
     * the actual value was not equal to the expected value.
     */
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

    /**
     * Atomically sets the value to the given updated value
     * if the current value {@code ==} the expected value.
     *
     * <p>May <a href="package-summary.html#Spurious">fail spuriously</a>
     * and does not provide ordering guarantees, so is only rarely an
     * appropriate alternative to {@code compareAndSet}.
     *
     * @param expect the expected value
     * @param update the new value
     * @return true if successful.
     */
    public final boolean weakCompareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

    /**
     * Atomically increments by one the current value.
     *
     * @return the previous value
     */
    public final int getAndIncrement() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return current;
        }
    }

    /**
     * Atomically decrements by one the current value.
     *
     * @return the previous value
     */
    public final int getAndDecrement() {
        for (;;) {
            int current = get();
            int next = current - 1;
            if (compareAndSet(current, next))
                return current;
        }
    }

    /**
     * Atomically adds the given value to the current value.
     *
     * @param delta the value to add
     * @return the previous value
     */
    public final int getAndAdd(int delta) {
        for (;;) {
            int current = get();
            int next = current + delta;
            if (compareAndSet(current, next))
                return current;
        }
    }

    /**
     * Atomically increments by one the current value.
     *
     * @return the updated value
     */
    public final int incrementAndGet() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return next;
        }
    }

    /**
     * Atomically decrements by one the current value.
     *
     * @return the updated value
     */
    public final int decrementAndGet() {
        for (;;) {
            int current = get();
            int next = current - 1;
            if (compareAndSet(current, next))
                return next;
        }
    }

    /**
     * Atomically adds the given value to the current value.
     *
     * @param delta the value to add
     * @return the updated value
     */
    public final int addAndGet(int delta) {
        for (;;) {
            int current = get();
            int next = current + delta;
            if (compareAndSet(current, next))
                return next;
        }
    }

    /**
     * Returns the String representation of the current value.
     * @return the String representation of the current value.
     */
    public String toString() {
        return Integer.toString(get());
    }


    public int intValue() {
        return get();
    }

    public long longValue() {
        return (long)get();
    }

    public float floatValue() {
        return (float)get();
    }

    public double doubleValue() {
        return (double)get();
    }

}

    　　成员变量

private volatile int value;//值
private static final Unsafe unsafe = Unsafe.getUnsafe();//底层实现类unsafe
private static final long valueOffset;//值相对于对象的偏移量

  　　静态代码块(关于unsafe的objectFieldOffset这个方法可以参见另外一篇文章,链接

 static {
      try {
        //偏移量
        valueOffset = unsafe.objectFieldOffset
            (AtomicInteger.class.getDeclaredField("value")); 
      } catch (Exception ex) { throw new Error(ex); }
    }

    构造函数

 /**
     * Creates a new AtomicInteger with the given initial value.
     *
     * @param initialValue the initial value
     */
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }

    /**
     * Creates a new AtomicInteger with initial value {@code 0}.
     */
    public AtomicInteger() {
    }

   get/set方法

 /**
     * Gets the current value.
     *
     * @return the current value
     */
    public final int get() {
        return value;
    }

    /**
     * Sets to the given value.
     *
     * @param newValue the new value
     */
    public final void set(int newValue) {
        value = newValue;
    }

getAndSet

    /**
     * Atomically sets to the given value and returns the old value.
     *
     * @param newValue the new value
     * @return the previous value
     */
    public final int getAndSet(int newValue) {
        for (;;) {
            int current = get();
            if (compareAndSet(current, newValue))
                return current;
        }
    }

先调用get方法获取当前的值,然后无限循环调用compareAndSet方法来将当前的值更新为新的值,看下compareAndSet的源码

compareAndSet

  /**
     * Atomically sets the value to the given updated value
     * if the current value {@code ==} the expected value.
     *
     * @param expect the expected value
     * @param update the new value
     * @return true if successful. False return indicates that
     * the actual value was not equal to the expected value.
     */
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

可以看出调用了unsafe.compareAndSwapInt来更新值,compareAndSwapInt这个方法就是在CAS文章中提到的jdk中针对CAS,cpu指令提供的语言的实现,这个最后还是在cpu层面实现.

 继续看其他方法

getAndIncrement

    /**
     * Atomically increments by one the current value.
     *
     * @return the previous value
     */
    public final int getAndIncrement() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return current;
        }
    }

先获取当前的值,然后把当前的值增加1,然后调用compareAndSet方法将值更新为新值,一直到成功为止,返回之前的旧值

incrementAndGet

    /**
     * Atomically increments by one the current value.
     *
     * @return the updated value
     */
    public final int incrementAndGet() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return next;
        }
    }

类似getAndIncrement 但是最后返回的不是旧值而是新值,其实这个很好判断,看方法名,get在前就说明返回get的值,increment在前就说明返回increment操作以后的值

getAndAdd

    /**
     * Atomically adds the given value to the current value.
     *
     * @param delta the value to add
     * @return the previous value
     */
    public final int getAndAdd(int delta) {
        for (;;) {
            int current = get();
            int next = current + delta;
            if (compareAndSet(current, next))
                return current;
        }
    }

大同小异,只是把+1变成了加上指定的值,返回之前的值

lazzySet

    /**
     * Eventually sets to the given value.
     *
     * @param newValue the new value
     * @since 1.6
     */
    public final void lazySet(int newValue) {
        unsafe.putOrderedInt(this, valueOffset, newValue);
    }

先拿来跟set方法对比下发现lazySet的注释写的是 最终会设置成给的值(也许不保证可见性?),我们继续点到unsafe的putOrderedInt方法中可以看到

    public native void putOrderedInt(Object var1, long var2, int var4);

这个方法调用了本地方法,看不到具体实现,所以只能找找别的资料,于是我在so上搜到了这样一个解释

As probably the last little JSR166 follow-up for Mustang, we added a "lazySet" method to the Atomic classes (AtomicInteger, AtomicReference, etc). This is a niche method that is sometimes useful when fine-tuning code using non-blocking data structures. The semantics are that the write is guaranteed not to be re-ordered with any previous write, but may be reordered with subsequent operations (or equivalently, might not be visible to other threads) until some other volatile write or synchronizing action occurs).

The main use case is for nulling out fields of nodes in non-blocking data structures solely for the sake of avoiding long-term garbage retention; it applies when it is harmless if other threads see non-null values for a while, but you'd like to ensure that structures are eventually GCable. In such cases, you can get better performance by avoiding the costs of the null volatile-write. There are a few other use cases along these lines for non-reference-based atomics as well, so the method is supported across all of the AtomicX classes.

For people who like to think of these operations in terms of machine-level barriers on common multiprocessors, lazySet provides a preceeding store-store barrier (which is either a no-op or very cheap on current platforms), but no store-load barrier (which is usually the expensive part of a volatile-write).

简单来说就是lazyset这个方法是非volatile的,使用这个方法更改状态是不能保证这次更改对其他线程可见的,但是提高了更高的写入性能,所以使用见仁见智.

weekCompareAndSet

    /**
     * Atomically sets the value to the given updated value
     * if the current value {@code ==} the expected value.
     *
     * <p>May <a href="package-summary.html#Spurious">fail spuriously</a>
     * and does not provide ordering guarantees, so is only rarely an
     * appropriate alternative to {@code compareAndSet}.
     *
     * @param expect the expected value
     * @param update the new value
     * @return true if successful.
     */
    public final boolean weakCompareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

这个方法很奇怪,奇怪的地方在于他的实现和compareAndSet是一毛一样的,但是上面的注释却说这个方法可能失败!!!令我十分不解,然后我去jdk文档的atomic包说明中找到了相关描述

• 以原子方式读取和有条件地写入变量但不 创建任何 happen-before 排序，因此不提供与除 weakCompareAndSet 目标外任何变量以前或后续读取或写入操作有关的任何保证。所以事情就指向了happen-before是什么鬼

继续搜 一直找到这篇文章 http://www.ibm.com/developerworks/library/j-jtp09238/index.html

Visibility failures

More subtle than atomicity failures are visibility failures. In the absence of synchronization, if one thread writes to a variable and another thread reads that same variable, the reading thread could see stale, or out-of-date, data. Worse, it is possible for the reading thread to see up-to-date data for variable x and stale data for variable y, even if y was written before x. Visibility failures are subtle because they don't happen predictably, or even frequently, causing rare and difficult-to-debug intermittent failures. Visibility failures are created by data races — failure to properly synchronize when accessing shared variables. Programs with data races are, for all intents and purposes, broken, in that their behavior cannot be reliably predicted.

The Java Memory Model (JMM) defines the conditions under which a thread reading a variable is guaranteed to see the results of a write in another thread. (A full explanation of the JMM is beyond the scope of this article; see Resources.) The JMM defines an ordering on the operations of a program called happens-before. Happens-before orderings across threads are only created by synchronizing on a common lock or accessing a common volatile variable. In the absence of a happens-before ordering, the Java platform has great latitude to delay or change the order in which writes in one thread become visible to reads of that same variable in another.

The code in Listing 2 has visibility failures as well as atomicity failures. The updateHighScore() method retrieves the HighScore object from the ServletContext and then modifies the state of the HighScore object. The intent is for those modifications to be visible to other threads that call getHighScore(), but in the absence of a happens-before ordering between the writes to the name and score properties inupdateHighScore() and the reads of those properties in other threads calling getHighScore(), we are relying on good luck for the reading threads to see the correct values.

英语不太好基本快阵亡了,不过大致还是看懂了解释,意思就是 一个线程写一个变量的值的时候要保证其他线程在读取这个值的时候是能看到写操作的(这不就是可见性么),JMM就把这一系列的操作称为happen-before,weekCompareAndSet和compareAndSet

区别在于week不会创建happen-before序列,所以也就是不提供可见性,所以有可能失败.(不过实现一毛一样是为什么!!),这个解释纯粹是自己理解,有高人可以留言解释下,实在是不太懂.

 其他方法就不分析,基本都是类似的.关于unsafe不太懂的可以去看看关于CAS的那篇文章.

至于其他原子类AtomicLong等其他基本都是unsafe的包装类,不过有点需要注意,unsafe关于cas只提供了三种

 所以很多其他的类似 AtomicBoolean 中的compareAndSet方法都是转换成unsafe.compareAndSwapInt来调用

    /**
     * Atomically sets the value to the given updated value
     * if the current value {@code ==} the expected value.
     *
     * @param expect the expected value
     * @param update the new value
     * @return true if successful. False return indicates that
     * the actual value was not equal to the expected value.
     */
    public final boolean compareAndSet(boolean expect, boolean update) {
        int e = expect ? 1 : 0;
        int u = update ? 1 : 0;
        return unsafe.compareAndSwapInt(this, valueOffset, e, u);
    }

Atomic包 大致如此...核心类还是unsafe和cas思想.

最后附上该包下面所有类的测试代码!

package com.iwjw.learn.thread;

import java.util.concurrent.atomic.*;

/**
 * 原子类的包测试
 */
public class AtomicTest {
    static class Student {
        private Long id;

        public Student() {
        }

        public Student(Long id) {
            this.id = id;
        }

        public Long getId() {
            return id;
        }

        public void setId(Long id) {
            this.id = id;
        }
    }

    static class Person {

        private int age;
        private String name;
        public volatile Student student = new Student(10086l);

        public volatile int length;
        public volatile long tall;

        public Person(int length) {
            this.length = length;
        }

        public Person(long tall) {
            this.tall = tall;
        }

        public Person(int age, String name) {
            this.age = age;
            this.name = name;
        }

        public Person() {
        }

        public long getTall() {
            return tall;
        }

        public void setTall(long tall) {
            this.tall = tall;
        }

        public int getLength() {
            return length;
        }

        public void setLength(int length) {
            this.length = length;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public Student getStudent() {
            return student;
        }

        public void setStudent(Student student) {
            this.student = student;
        }
    }


    public static void main(String[] args) {
//        atomicIntegerTest();
//        atomicLongTest();
//        atomicBooleanTest();
//        atomicRefTest();
//        atomicIntegerArrayTest();
//        atomicLongArrayTest();
//        atomicRefArrayTest();
//        atomicIntegerFieldUpdaterTest();
//        atomicLongFieldUpdaterTest();
//        atomicRefFieldUpdterTest();
//        atomicMarkableRefTest();
//        atomicStampedRefTest();
    }


    /**
     * 测试 atomicInteger
     */
    private static void atomicIntegerTest() {
        AtomicInteger integer = new AtomicInteger(1);
        System.out.println("get:" + integer.get());//1
        System.out.println("incrementAndGet:" + integer.incrementAndGet());//2
        System.out.println("getAndIncrement:" + integer.getAndIncrement());//2
        System.out.println("getAndSet(10):" + integer.getAndSet(10));//3
        System.out.println("compareAndSet(10,15):" + integer.compareAndSet(10, 15));//true
        System.out.println("compareAndSet(14,20):" + integer.compareAndSet(14, 20));//false
        System.out.println("integer :" + integer);//15
    }

    /**
     * 测试 atomicLong
     */
    private static void atomicLongTest() {
        AtomicLong value = new AtomicLong(1L);
        System.out.println("get:" + value.get());//1
        System.out.println("getAndIncrement:" + value.getAndIncrement());//1
        System.out.println("incrementAndGet:" + value.incrementAndGet());//3
        System.out.println("getAndSet(10):" + value.getAndSet(10l));//3
        System.out.println("compareAndSet(10,15):" + value.compareAndSet(10, 15));//true
        System.out.println("compareAndSet(14,20):" + value.compareAndSet(14, 20));//false
        System.out.println("AtomicLong:" + value);//15

    }

    /**
     * 测试 atomicBoolean
     */
    private static void atomicBooleanTest() {
        AtomicBoolean value = new AtomicBoolean(false);
        System.out.println("value:" + value.get());//false
        System.out.println("getAndSet:" + value.getAndSet(true));//false
        System.out.println("compareAndSet(t,f):" + value.compareAndSet(true, false));//true
        System.out.println("AtomicBoolean:" + value);//false
    }

    /**
     * 测试atomicReference
     */
    private static void atomicRefTest() {
        AtomicReference<AtomicTest.Person> value = new AtomicReference<Person>(new AtomicTest.Person(15, "a"));
        Person a = value.get();
        Person b = new Person(11, "b");
        System.out.println("current name :" + a.getName());//a
        System.out.println("current name getAndSet:" + value.getAndSet(b).getName());//a
        System.out.println("current name " + value.get().getName());//b
    }


    /**
     * 测试AtomicIntegerArray
     */
    private static int[] intArray = {1, 2, 3, 4, 5};

    private static void atomicIntegerArrayTest() {
        AtomicIntegerArray array = new AtomicIntegerArray(intArray);
        array.getAndAdd(0, 10);
        array.getAndSet(1, 10);
        array.incrementAndGet(2);
        System.out.println(array.get(0));//11
        System.out.println(array.get(1));//10
        System.out.println(array.get(2));//4
        System.out.println(array.compareAndSet(0, 11, 10086));//true
        System.out.println(array.get(0));//10086
    }

    /**
     * 测试 AtomicLongArray
     */
    private static void atomicLongArrayTest() {
        //长度 构造函数 初始化为{0,0,0,0,0.....}
        AtomicLongArray arr = new AtomicLongArray(10);//{0,0,0,0....}
        System.out.println("get(index):" + arr.get(0)); //0
        System.out.println(arr.incrementAndGet(7));//1
        System.out.println(arr.decrementAndGet(5));//-1
        System.out.println(arr.getAndIncrement(8));//0
        System.out.println(arr.compareAndSet(9, 0, 1));//true
    }


    /**
     * 测试AtomicReferenceArray
     */
    private static void atomicRefArrayTest() {
        AtomicReferenceArray<Person> arr = new AtomicReferenceArray<Person>(5);//[null, null, null, null, null]
        System.out.println(arr.get(0));
        Person a = new Person(1, "a");
        Person b = new Person(2, "b");
        arr.getAndSet(0, a);
        System.out.println(arr.get(0).getName());//a
        System.out.println(arr.compareAndSet(0, a, b));//true
        System.out.println(arr.get(0).getName());//b
    }


    /**
     * 测试 AtomicIntegerFieldUpdater
     */
    private static void atomicIntegerFieldUpdaterTest() {
        Person a = new Person(1);
        AtomicIntegerFieldUpdater<Person> updater = AtomicIntegerFieldUpdater.newUpdater(Person.class, "length");
        System.out.println(updater.get(a));//1
        System.out.println(updater.compareAndSet(a, 1, 180));//true
        System.out.println(updater.get(a));//180
    }

    /**
     * 测试 AtomicLongFieldUpdater
     */
    private static void atomicLongFieldUpdaterTest() {
        Person a = new Person(180l);
        AtomicLongFieldUpdater<Person> updater = AtomicLongFieldUpdater.newUpdater(Person.class, "tall");
        System.out.println(updater.get(a));//180
        System.out.println(updater.compareAndSet(a, 180l, 190l));//true
        System.out.println(updater.get(a));//190
    }

    /**
     * 测试 AtomicReferenceFieldUpdater
     */
    private static void atomicRefFieldUpdterTest() {
        Person p = new Person();
        AtomicReferenceFieldUpdater<Person, Student> ref = AtomicReferenceFieldUpdater.newUpdater(Person.class, Student.class, "student");
        Student a = new Student(2l);
        Student defaultStudent = ref.get(p);
        System.out.println(ref.get(p).getId());//1
        System.out.println(ref.compareAndSet(p, defaultStudent, a));//true
        System.out.println(ref.get(p).getId());//2
    }


    /**
     * 测试 AtomicMarkableRef
     * 相当于AtomicReference 和 Boolean mark 2个字段的包装体
     */
    private static void atomicMarkableRefTest() {
        Person a = new Person(11, "a");
        Person b = new Person(1, "b");
        AtomicMarkableReference<Person> ref = new AtomicMarkableReference<Person>(a, false);
        boolean[] arr1 = {false};
        System.out.println(ref.getReference().getName());//a
        System.out.println(ref.get(arr1));//a
        System.out.println(ref.attemptMark(a, false));//true
        System.out.println(ref.isMarked());//false
        System.out.println(ref.compareAndSet(a, b, false, true));//true
        System.out.println(ref.getReference().getName());//b
        System.out.println(ref.isMarked());//true
    }


    /**
     * 测试 AtomicStampedRef
     * 相当于atomicReference 和一个Integer 的包装
     */
    private static void atomicStampedRefTest() {

        Person a = new Person(11, "a");
        Person b = new Person(1, "b");
        AtomicStampedReference<Person> ref = new AtomicStampedReference<Person>(a, 0);
        int[] arr = {10};
        System.out.println(ref.getReference().getName());//a
        System.out.println(ref.getStamp());//0
        System.out.println(ref.get(arr));//a
        System.out.println(ref.attemptStamp(a, 10));//true
        System.out.println(ref.getStamp());//10
        System.out.println(ref.compareAndSet(a, b, 10, 10086));//true
        System.out.println(ref.getStamp());//10086
    }

}