自動包裝機制Integer，與AtomicReference 的問題

從如下代碼開始了解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); 23         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) { 25         if (i >= IntegerCache.low && i <= IntegerCache.high) 26             return IntegerCache.cache[i + (-IntegerCache.low)]; 27         return new Integer(i); 28  } 29     /**
     * 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。

 

本文結束。