在竞争激烈的情况下，ReentrantLock与CAS的性能比较

这次看了源码，发现ReentrantLock的底层实现是AQS，而AQS底层实现是Volatile+CAS+CLH队列，因此想看看ReentrantLock与CAS的性能比较，因此做了这么一组实验。

// 使用ReentrantLock
class LockRunnable implements Runnable {
    static int i = 0;

    private ReentrantLock lock;

    private int loopNumber;

    public LockRunnable(ReentrantLock lock, int loopNumber) {
        this.lock = lock;
        this.loopNumber = loopNumber;
    }

    @Override
    public void run() {

        // 将加锁解锁卸载for放在内部，从而让锁的竞争变得激烈
        for (int j = 0; j < loopNumber; j++) {
            try {
                lock.lock();
                this.i++;
            }
            finally {
                lock.unlock();
            }
        }

    }
}

// 使用AtomicInteger，其底层实现是CAS
class CASRunnable implements Runnable {

    private AtomicInteger ai;

    private int loopNumber;

    public CASRunnable(AtomicInteger ai, int loopNumber) {
        this.ai = ai;
        this.loopNumber = loopNumber;
    }

    @Override
    public void run() {
        // 将incrementAndGet放在for循环内部，从而让CAS激烈，同时与Lock的数量保持一致
        for (int j = 0; j < loopNumber; j++) {
            ai.incrementAndGet();
        }
    }

}

public class Main {
    static ReentrantLock lock = new ReentrantLock();
    final static int THREAD_NUMBER = 1000;

    public static void test(int loopNumber) throws InterruptedException {
        System.out.println("--------------------loop number:" + loopNumber
                + "------------------");
        LockRunnable.i=0;
        Date begin = new Date();
        List ts = new ArrayList<>();
        for (int i = 0; i < THREAD_NUMBER; i++) {
            Thread t = new Thread(new LockRunnable(lock, loopNumber));
            ts.add(t);
            t.start();
        }

        for (Thread t : ts)
            t.join();

        System.out.println("--------------------LockRunnable--------------");
        System.out.println(LockRunnable.i);
        System.out.println(System.currentTimeMillis() - begin.getTime());
        begin = new Date();
        ts.clear();
        AtomicInteger ai = new AtomicInteger(0);
        for (int i = 0; i < THREAD_NUMBER; i++) {
            Thread t = new Thread(new CASRunnable(ai, loopNumber));
            ts.add(t);
            t.start();
        }

        for (Thread t : ts)
            t.join();

        System.out.println("--------------------CASRunnable--------------");
        System.out.println(ai.get());
        System.out.println(System.currentTimeMillis() - begin.getTime());
    }

    public static void main(String[] args) throws InterruptedException {
        test(100000);
        test(1000000);
    }
}

实验结果

--------------------loop number:100000------------------
--------------------LockRunnable--------------
100000000
2426
--------------------CASRunnable--------------
100000000
1726
--------------------loop number:1000000------------------
--------------------LockRunnable--------------
1000000000
23546
--------------------CASRunnable--------------
1000000000
16169

从实验结果来看，CAS大概比ReentrantLock快0.7倍左右。