Почему мой собственный AtomicLong работает медленнее, чем тот, что есть в JDK?

Question

Я писал свой AtomicLong класс, и я только что обнаружил, что функция, которую я имел, намного медленнее, чем та, что предусмотрена в классе Unsafe. Мне интересно почему?

Ниже приведены коды, которые у меня есть:

public interface Counter {
    void increment();
    long get();
}


public class PrimitiveUnsafeSupportCounter implements Counter{

    private volatile long count = 0;
    private Unsafe unsafe;
    private long offset;

    public PrimitiveUnsafeSupportCounter() throws IllegalAccessException, NoSuchFieldException {
        Field f = Unsafe.class.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        this.unsafe = (Unsafe) f.get(null);
        this.offset = this.unsafe.objectFieldOffset(PrimitiveUnsafeSupportCounter.class.getDeclaredField("count"));
    }

    @Override
    public void increment() {

        this.unsafe.getAndAddLong(this, this.offset, 1);
    }

    @Override
    public long get() {
        return this.count;
    }
}

public class CounterThread implements Runnable {

    private Counter counter;

    public CounterThread(Counter counter){
        this.counter = counter;
    }
    @Override
    public void run() {

        for (int i = 0; i < 100000; i ++){
            this.counter.increment();
        }
    }
}

class Test{

    public static void test(Counter counter) throws NoSuchFieldException, IllegalAccessException, InterruptedException {

        ExecutorService executor = Executors.newFixedThreadPool(1000);

        long start = System.currentTimeMillis();
        for (int i = 0 ; i < 1000; i++){
            executor.submit(new CounterThread(counter));
        }

        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.MINUTES);
        long stop = System.currentTimeMillis();

        System.out.println(counter.get());
        System.out.println(stop - start);
    }

}

public class Main {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, InterruptedException {

        Counter primitiveUnsafeSupportCounter = new PrimitiveUnsafeSupportCounter();
        Test.test(primitiveUnsafeSupportCounter);

    }

}

для завершения вышеуказанных кодов требуется около 3000 мс. однако, если я использовал приведенные ниже коды вместо this.unsafe.getAndAddLong(this, this.offset, 1);,

long before;
do {
     before = this.unsafe.getLongVolatile(this, this.offset);
} while (!this.unsafe.compareAndSwapLong(this, this.offset, before, before + 1));

Я прошел через исходники getAndAddLong и обнаружил, что он делает почти то же самое, что и приведенные выше коды, так что я должен пропустить?

Answer 1

Это встроенная и написанная от руки версия цикла JVM для этой цели имеет крайне неэффективный скомпилированный код. На x86 вы можете иметь атомарную версию таких операций чтения-изменения-записи через lock префикс. См. Руководство Intel 8.1.2.2 "Программная блокировка шины":

Чтобы явно форсировать семантику LOCK, программное обеспечение может использовать префикс LOCK со следующими инструкциями, когда они используются для изменения области памяти.

В частности, вы можете иметь что-то вроде lock add op1 op2, В вашем примере вы проверяете результат cmpxchg и сделать прыжок, который, очевидно, медленнее. Также, насколько я помню, для x86 энергозависимый доступ требует какого-то mfence или же lock обеспечить порядок памяти.