Warum AtomicReference CAS false mit Wert 128 zurückgeben?

Question

Ich verwendete AtomicReference, um AtomicInteger zu implementieren. Aber während des Testens merke ich sogar in einer Single-Threaded-Umgebung, dass die CAS-Operation stecken geblieben ist, sobald ihr Wert 128 erreicht hat. Mache ich etwas falsch oder gibt es einen Vorbehalt in AtomicReference (kann mit der CPU zusammenhängen)? Hier ist mein Code:

public class MyAtomInt { 
    private final AtomicReference<Integer> ref; 

    public MyAtomInt(int init) { 
    ref = new AtomicReference<Integer>(init); 
    } 

    public MyAtomInt() { 
    this(0); 
    } 

    public void inc() { 
    while (true) { 
     int oldVal = ref.get(); 
     int nextVal = oldVal + 1; 
     boolean success = ref.compareAndSet(oldVal, nextVal); // false once oldVal = 128 
     if (success) { 
     return; 
     } 
    } 
    } 

    public int get() { 
    return ref.get(); 
    } 

    static class Task implements Runnable { 

    private final MyAtomInt myAtomInt; 
    private final int incCount; 

    public Task(MyAtomInt myAtomInt, int cnt) { 
     this.myAtomInt = myAtomInt; 
     this.incCount = cnt; 
    } 

    @Override 
    public void run() { 
     for (int i = 0; i < incCount; ++i) { 
     myAtomInt.inc(); 
     } 
    } 
    } 

    public static void main(String[] args) throws Exception { 
    MyAtomInt myAtomInt = new MyAtomInt(); 
    ExecutorService exec = Executors.newSingleThreadExecutor(); 
    exec.submit(new Task(new MyAtomInt(), 150)).get(); 
    System.out.println(myAtomInt.get()); 
    exec.shutdown(); 
    } 
} 

Answer 1

Der Grund dafür ist, dass, wenn Sie einen int in eine Integer Box, können Sie oder keine neue Integer Instanz erstellen können. Wenn Sie dies tun, weist die neue Instanz möglicherweise keine Referenzgleichheit mit anderen Instanzen auf, auch wenn sie denselben Wert haben. AtomicReference.compareAndSet() verwendet Referenzgleichheit (Identität) für Vergleiche.

Der Schlüssel ist, wie der Compiler das automatische Boxen von int Werte behandelt: es sendet Aufrufe an Integer.valueOf(). Als Optimierung hat Integer.valueOf() einen Cache von Boxed Integers, und standardmäßig enthält dieser Cache Werte bis zu 128. Wenn Sie eine Integer n zweimal boxen, erhalten Sie immer die gleiche Integer Referenz zurück, wenn der Wert klein genug war der Cache; Andernfalls erhalten Sie zwei separate Instanzen.

Derzeit entpacken Sie den alten Wert, berechnen Sie den neuen Wert, und wenn Sie compareAndSet() aufrufen, boxen Sie den alten Wert erneut. Sobald Sie 128 erreicht haben, hören Sie auf, zwischengespeicherte Werte zu erhalten, sodass die zweite Kopie nicht länger die gleiche ist wie die in der AtomicReference.