自动包装机制Integer，与AtomicReference<Integer>的问题

从如下代码开始了解Integer的自动包装机制

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;

/**
 * 比较方法一与方法二的区别
 */
public class AtomicIntegerDemo {

    static void demo1(){
        AtomicInteger atomicInteger = new AtomicInteger(100);
        atomicInteger.compareAndSet(100, 200);
        atomicInteger.compareAndSet(200, 400);
        System.out.println(atomicInteger.get());
    }

    /**
     * 需要仔细了解此例输出
     */
    static void demo2(){
        AtomicReference<Integer> atomicReference = new AtomicReference<>(100);
        atomicReference.compareAndSet(100, 200);
        atomicReference.compareAndSet(200, 400);
        System.out.println(atomicReference.get());
    }
    
    public static void main(String[] args) {
        demo1();
        demo2();
    }
}

此代码的输出如下：

400
200

Process finished with exit code 0

预期demo2()方法最终输出400，但结果并不是。

问题根源，自动包装机制：

public final class Integer extends Number implements Comparable<Integer> {
    /**
     * The value of the {@code Integer}.
     *
     * @serial
     */
    private final int value;

    /**
     * Returns an {@code Integer} instance representing the specified
     * {@code int} value.  If a new {@code Integer} instance is not
     * required, this method should generally be used in preference to
     * the constructor {@link #Integer(int)}, as this method is likely
     * to yield significantly better space and time performance by
     * caching frequently requested values.
     *
     * This method will always cache values in the range -128 to 127,
     * inclusive, and may cache other values outside of this range.
     *
     * @param  i an {@code int} value.
     * @return an {@code Integer} instance representing {@code i}.
     * @since  1.5
     */
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
    /**
     * Cache to support the object identity semantics of autoboxing for values between
     * -128 and 127 (inclusive) as required by JLS.
     *
     * The cache is initialized on first usage.  The size of the cache
     * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
     * During VM initialization, java.lang.Integer.IntegerCache.high property
     * may be set and saved in the private system properties in the
     * sun.misc.VM class.
     */

    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];
        . . .
    }
. . .
}

AtomicReference中对象的比较为地址的比较。对于int字面量java会进行装箱将其转换成Integer对象，调用的是Integer.valueOf方法， 看源码你就明白了，128以内的会使用缓存，同一个int字面量返回同一个对象用==比较为true，而超过128返回不是同一个对象，==为false，equal才是true。

本文结束。