一个比较悲观锁和 CAS 乐观锁性能的简单实例引发的问题

大家周末好！

线程安全和锁这一块一直是我想理解清楚的问题，今天看了 https://www.v2ex.com/t/574995#reply13 的问题，再次引发了我对 java 锁这块知识的疑问。

我从网络上得知，使用 synchronized 包裹方法来实现悲观锁，这是重量级的，是性能不高的。使用 CAS 实现乐观锁，这是轻量级的，一定场合下性能高于前者。

所以我就想自己测下验证下这个结论，但是验证过程中遇到了和结论不匹配的结果，所以希望请教下大家

我的示例代码如下

public class Demo1 {
    private static final Sheep sheep = new Sheep(0);

    static class Sheep{
        private AtomicInteger size;

        public Sheep(int size) {
            this.size = new AtomicInteger(0);
        }

        public AtomicInteger getSize() {
            return size;
        }

        public void setSize(int size) {
            this.size.set(size);
        }

    }

    //悲观
    public synchronized static void increase1() {
        int value = sheep.getSize().intValue();
        sheep.setSize(value + 1);
    }

    //乐观(CAS)
    public static void increase2() {
        while (true){
            int expect = sheep.getSize().intValue();
            if(sheep.getSize().compareAndSet(expect,expect+1)){
                break;
            }
        }
    }
}

我使用如下代码来做耗时测试：

//10 个线程模拟 10 个用户，它们同时调用递增方法修改 size 属性,记录每次的耗时结果
public static void main(String[] args)  throws InterruptedException{
        long start = System.currentTimeMillis();
        long end = 0;

        ExecutorService executor = Executors.newFixedThreadPool(10);
        int callTime = 10000000;
        CountDownLatch countDownLatch = new CountDownLatch(callTime);
        
        for(int i=0; i<callTime; i++) {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    increase1();
                    //increase2();
                    countDownLatch.countDown();
                }
            });
        }
        
        countDownLatch.await();
        end = System.currentTimeMillis();
        executor.shutdown();
        
        System.out.println("调用次数：" + sheep.getSize().intValue());
        System.out.println("调用耗时: " + (end - start) );
    }

我的记录结果如下：

 *      总共操作 1000w 次，两者的耗时差不多,记录了 5 次运行的耗时：
 *      悲观递增耗时记录(毫秒)：6923，7030，6987，7353，7125
 *      乐观递增耗时记录(毫秒)：7149，7044，6937，6777，6717
 *
 *      总共操作 5000w 次，两者的耗时差不多,记录了 5 次运行的耗时：
 *      悲观递增耗时记录(毫秒)：49843，49807，51404，49143，49543
 *      乐观递增耗时记录(毫秒)：49762，48950，49376，48918，50324
 *
 *      测试环境是 IDEA，跑 main 方法

可以看到，这个案例下，悲观锁和 CAS 乐观锁在效率上没有很大的区别！为什么在这个案例下这两种实现在效率上没有区别呢？