java - JavaのAtomicIntegerと同期されたint変数:パフォーマンスの違い

Question

次の質問を行った後、 同期ブロックは Atomics よりも高速になりますか? ということで、AtomicIntegerと同期ブロック(その中でintをインクリメント)
の性能差を比較する簡単なプログラムを書いてみました。このプログラムを実行するたびに、比率が 100 を超えます。

    System.out.println(Runtime.getRuntime().availableProcessors())

私が使うとき

    THREAD_COUNT = 1;

比率は最小になります。100前後で変動します。

    THREAD_COUNT = 10;  

倍率は800前後。

質問 1 : AtomicInteger VS 同期されたインクリメント() メソッドのパフォーマンスの違いをテストする正しい方法を教えてください。

質問 2 : を増やすTHREAD_COUNTと比率が増えるのはなぜですか? より多くのスレッドが同期ステートメントでブロックされ、CPU により多くのタスクが必要になるためだと思います。コメントしてください。

package concurrent.atomic;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

public class Performance {

    private static final AtomicInteger atomicInt = new AtomicInteger(0);
    private static volatile int counter = 0;
    private static final Object LOCK = new Object();
    private static final int THREAD_COUNT = 10;

    public static void main(String[] args) {

        System.out.println(Runtime.getRuntime().availableProcessors()); 

        Runnable atomic = new Runnable() {
            @Override
            public void run() {
                while (!Thread.currentThread().isInterrupted()) {
                    int value = atomicInt.incrementAndGet();
                    //if (value % 1000 == 0)
                        //System.out.println("atomic value : "+value);
                }   
            }
        };
        //System.out.println("1");
        Runnable intCounter = new Runnable() {
            @Override
            public void run() {
                while (!Thread.currentThread().isInterrupted()) {
                    synchronized (LOCK) {
                        int value = ++counter;
                        //if (value % 1000 == 0)
                            //System.out.println("sync value "+value);
                    }
                }   
            }
        };

        final ExecutorService atomicExecutor = Executors.newCachedThreadPool();
        final ExecutorService primitiveExecutor = Executors.newCachedThreadPool();
        for (int i = 0; i < THREAD_COUNT ; ++i) {
            atomicExecutor.submit(atomic);
            primitiveExecutor.submit(intCounter);
        }

        while (true) {
            float ratio = (((float) (atomicInt.get() * 1.0) ) / counter) * 100;
            System.out.println("ratio : " + ratio);
        }
    }
}