ReetrantLock Synchronized Atomic的性能对比

之前看到了一篇帖子关于Lock和Synchronized的性能，写的是Lock比Synchronized的性能要好，可是，我试了下，结果却不是这样的。

之后看了这篇文章，http://www.cnblogs.com/Mainz/p/3546347.html，估计我是构建了一个比较特殊的高度争用的场景。

下面是我测试性能的代码：

package juc;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 测试Lock Synchronized Atomic的性能
 * Lock来改变变量，则必须用volatile修释，Atomic和Sychronized则保证了原子性和可见性
 * 耗时：Synchronized < ReetrantLock < Atomic
 * 可能JDK 1.7之后对Synchronized做了比较大的优化，以至于效率最高
 * @author jiujie
 * @version $Id: TestSpeed.java, v 0.1 2016年6月22日 上午10:24:42 jiujie Exp $
 */
public class TestSpeed {

    private static final int LOOP_SIZE      = 100000;

    private static final int MAX_THREAD_NUM = 30;

    public static class IntBox {

        private Lock lock = new ReentrantLock();

        private int  value;

        public IntBox(int value) {
            this.value = value;
        }

        public int getValue() {
            return value;
        }

        public synchronized void sychronizedIncrease() {
            value++;
        }

        public void lockIncrease() {
            lock.lock();
            try {
                value++;
            } finally {
                lock.unlock();
            }
        }

    }

    private static void executeThreads(Runnable runnable) throws InterruptedException {
        for (int threadNum = 0; threadNum < MAX_THREAD_NUM; threadNum++) {
            Thread[] threads = new Thread[threadNum];
            for (int i = 0; i < threadNum; i++) {
                threads[i] = new Thread(runnable);
            }
            for (Thread thread : threads) {
                thread.start();
            }
            for (Thread thread : threads) {
                thread.join();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {

        final AtomicInteger v1 = new AtomicInteger(0);

        final IntBox v2 = new IntBox(0);

        final IntBox v3 = new IntBox(0);

        long now = System.currentTimeMillis();
        executeThreads(new Runnable() {
            public void run() {
                testAtomicLock(v1);
            }
        });
        System.out.println("Atomic:\n" + v1.get() + "\n" + (System.currentTimeMillis() - now));

        now = System.currentTimeMillis();
        executeThreads(new Runnable() {
            public void run() {
                testLock(v2);
            }
        });
        System.out.println("Lock:\n" + v2.getValue() + "\n" + (System.currentTimeMillis() - now));

        now = System.currentTimeMillis();
        executeThreads(new Runnable() {
            public void run() {
                testSynchronize(v3);
            }
        });
        System.out
            .println("Synchronized:\n" + v3.getValue() + "\n" + (System.currentTimeMillis() - now));

    }

    public static void testSynchronize(final IntBox v) {
        for (int i = 0; i < LOOP_SIZE; i++) {
            v.sychronizedIncrease();
        }
    }

    public static void testLock(final IntBox v) {
        for (int i = 0; i < LOOP_SIZE; i++) {
            v.lockIncrease();
        }
    }

    public static void testAtomicLock(final AtomicInteger v) {
        for (int i = 0; i < LOOP_SIZE; i++) {
            v.getAndIncrement();
        }
    }

}

运行结果如下：

Atomic:

43500000

2998

Lock:

43500000

1541

Synchronized:

43500000

529