0

我已经阅读了大量文章，据说 AtomicInteger 类的工作速度比同步构造快。我对 AtomicInteger 和“同步”进行了一些测试，在我的测试中，同步比 AtomicInteger 快得多。我想了解出了什么问题：我的测试类不正确或 AtomicInteger 在其他情况下工作得更快？

这是我的测试课：

    public class Main {

    public static void main(String[] args) throws InterruptedException
    {
        // creating tester "synchronized" class
        TesterSynchronized testSyn = new TesterSynchronized();

        // Creating 3 threads
        Thread thread1 = new Thread(testSyn);
        Thread thread2 = new Thread(testSyn);
        Thread thread3 = new Thread(testSyn);

        // start time
        long beforeSyn = System.currentTimeMillis();

        // start
        thread1.start();
        thread2.start();
        thread3.start();

        thread1.join();
        thread2.join();
        thread3.join();

        long afterSyn = System.currentTimeMillis();
        long delta = afterSyn - beforeSyn;

        System.out.println("Test synchronized: " + delta + " ms");

        // _______________________________________________________

        // creating tester "atomicInteger" class
        TesterAtomicInteger testAtomic = new TesterAtomicInteger();

        thread1 = new Thread(testAtomic);
        thread2 = new Thread(testAtomic);
        thread3 = new Thread(testAtomic);

        // start time
        long beforeAtomic = System.currentTimeMillis();

        // start
        thread1.start();
        thread2.start();
        thread3.start();

        thread1.join();
        thread2.join();
        thread3.join();

        long afterAtomic = System.currentTimeMillis();
        long deltaAtomic = afterAtomic - beforeAtomic;

        System.out.println("Test atomic integer: " + deltaAtomic + " ms");
    }
}

// Synchronized tester
class TesterSynchronized implements Runnable {
    public int integerValue = 0;

    public synchronized void run() {
        for (int i = 0; i < 1_000_000; i++)
            integerValue++;
    }
}

// AtomicInteger class tester
class TesterAtomicInteger implements Runnable {
    AtomicInteger atomicInteger = new AtomicInteger(0);

    public void run() {
        for (int i = 0; i < 1_000_000; i++)
            atomicInteger.incrementAndGet();
    }
}

测试参数：3个线程和1_000_000个增量；结果：

测试同步：7 毫秒。测试原子整数：51 ms

我很高兴了解为什么会这样。

UPD如果将同步方法更改为同步块 ，则测试将正确。

// Synchronized tester
class TesterSynchronized implements Runnable {
    public int integerValue = 0;

    public void run() {
        for (int i = 0; i < 1_000_000; i++) {
            synchronized (this) {
                integerValue++;
            }
        }
    }
}
4

1 回答 1

2

您的代码中的明显区别在于，该AtomicIntger版本允许对具有任何访问权限的线程进行交错，而该synchronized版本依次对每个线程执行整个循环。

可能还有其他问题。例如，JVM 可以合并一个synchronized块的多个调用。根据平台的不同，incrementAndGet可能不是原子操作，而是作为 CAS 循环实现 - 如果争用很高，这可能是一个问题（我对此并不完全确定）。

无论以何种方式排列，如果您有多个线程同时修改相同的内存位置，它都不会很快。

于 2020-12-06T21:34:53.340 回答