重入锁reentrantlock 可以选择 公平锁和非公平锁。
内部锁synchronized 本身是 非公平锁。
从性能的角度上看， 非公平锁性能要远大于公平锁。
至于重入锁中非公平锁的性能和 内部锁synchronized的性能比较并没有谁优谁劣的情况。

以下例子是对 三者的性能对比：

下面具体的构造一个测试程序来具体考察 ReentrantLock 的性能。构造一个 计数器 Counter，启动 N 个线程对计数器进行递增操作。显然，这个递增操作需 要同步以防止数据冲突和线程干扰，为保证原子性，采用 3 种锁来实现同步，然 后查看结果。
测试环境是双核酷睿处理器，内存 3G，JDK6。
第一种是内在锁，第二种是不公平的 ReentrantLock 锁，第三种是公平的 ReentrantLock 锁。
首先定义一个计数器接口。

package locks;
public interface Counter {
    public long getValue();
    public void increment();
}

下面是使用内在锁的计数器类:

package lockbenchmark;
public class SynchronizedCounter implements Counter { 
    private long count = 0;
    public long getValue() {
        return count;
    }
    public synchronized void increment() { 
        count++;
    } 
}

下面是使用不公平 ReentrantLock 锁的计数器。

package lockbenchmark;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantUnfairCounterLockCounter implements Counter {
    private volatile long count = 0;
    private Lock lock;
    public ReentrantUnfairCounterLockCounter() {
    // 使用非公平锁，true就是公平锁
    lock = new ReentrantLock(false); 
    }
    public long getValue() { 
        return count;
    }
    public void increment() {
        lock.lock(); 
        try {
            count++; 
        } finally {
            lock.unlock();
        }
    } 
}

下面是使用公平的 ReentrantLock 锁的计数器。

package lockbenchmark;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantFairLockCounter implements Counter {
    private volatile long count = 0;
    private Lock lock;
    public ReentrantFairLockCounter() {
        // true就是公平锁
        lock = new ReentrantLock(true); 
    }
    public long getValue() { 
        return count;
    }
    public void increment() {
        lock.lock();
        try {
            count++; 
        } finally {
            lock.unlock();
        }
    }
}

下面是总测试程序。

package lockbenchmark;
import java.util.concurrent.CyclicBarrier;
public class BenchmarkTest {
    private Counter counter;
    // 为了统一启动线程，这样好计算多线程并发运行的时间
    private CyclicBarrier barrier;
    private int threadNum;// 线程数
    private int loopNum;// 每个线程的循环次数
    private String testName;
    public BenchmarkTest(Counter counter, int threadNum, int loopNum, String testName) {
        this.counter = counter;
        barrier = new CyclicBarrier(threadNum + 1); // 关卡计数=线程数
        this.threadNum = threadNum;
        this.loopNum = loopNum;
        this.testName = testName;
    }
    public static void main(String args[]) throws Exception {
        int threadNum = 2000;
        int loopNum = 1000;
        new BenchmarkTest(new SynchronizedCounter(), threadNum, loopNum, "内部锁").test();
        new BenchmarkTest(new ReentrantUnfairCounterLockCounter(), threadNum, loopNum, "不公平重入锁").test();
        new BenchmarkTest(new ReentrantFairLockCounter(), threadNum, loopNum, "公平重入锁").test();
    }
    public void test() throws Exception {
        try {
            for (int i = 0; i < threadNum; i++) {
                new TestThread(counter, loopNum).start();
            }
            long start = System.currentTimeMillis();
            barrier.await(); // 等待所有任务线程创建,然后通过关卡，统一执行
            barrier.await(); // 等待所有任务计算完成
            long end = System.currentTimeMillis();
            System.out.println(this.testName + " count value:" + counter.getValue());
            System.out.println(this.testName + " 花费时间:" + (end - start) + "毫秒");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    class TestThread extends Thread {
        int loopNum = 100;
        private Counter counter;
        public TestThread(final Counter counter, int loopNum) {
            this.counter = counter;
            this.loopNum = loopNum;
        }
        public void run() {
            try {
                barrier.await();// 等待所有的线程开始
                for (int i = 0; i < this.loopNum; i++)
                    counter.increment();
                barrier.await();// 等待所有的线程完成
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }
}

对三种锁分别设置两个不同的参数:不同线程数和每个线程数的循环次数。 最后记录每种锁的运行时间(单位:ms)，形成下表。

循环次数 1000

循环次数 200

分析统计结果，在线程数小于 2000 的情况下，非公平可重入锁的性能要优 于内部锁。公平可重入锁的性能最差。同时发现内部锁其实也是一个非公平锁。