死磕 java同步系列之ReentrantLock VS synchronized——结果可能跟你想的不同
问题
（1）ReentrantLock有哪些优势？java
（2）ReentrantLock有哪些缺点？c++
（3）ReentrantLock是否能够彻底替代synchronized？多线程
简介
synchronized是Java原生提供的用于在多线程环境中保证同步的关键字，底层是经过修改对象头中的MarkWord来实现的。oop
ReentrantLock是Java语言层面提供的用于在多线程环境中保证同步的类，底层是经过原子更新状态变量state来实现的。性能
既然有了synchronized的关键字来保证同步了，为何还要实现一个ReentrantLock类呢？它们之间有什么异同呢？测试
ReentrantLock VS synchronized
直接上表格：（手机横屏查看更方便）优化
| 功能 | ReentrantLock | synchronized |
|---|---|---|
| 可重入 | 支持 | 支持 |
| 非公平 | 支持（默认） | 支持 |
| 加锁/解锁方式 | 须要手动加锁、解锁，通常使用try..finally..保证锁可以释放 | 手动加锁，无需刻意解锁 |
| 按key锁 | 不支持，好比按用户id加锁 | 支持，synchronized加锁时须要传入一个对象 |
| 公平锁 | 支持，new ReentrantLock(true) | 不支持 |
| 中断 | 支持，lockInterruptibly() | 不支持 |
| 尝试加锁 | 支持，tryLock() | 不支持 |
| 超时锁 | 支持，tryLock(timeout, unit) | 不支持 |
| 获取当前线程获取锁的次数 | 支持，getHoldCount() | 不支持 |
| 获取等待的线程 | 支持，getWaitingThreads() | 不支持 |
| 检测是否被当前线程占有 | 支持，isHeldByCurrentThread() | 不支持 |
| 检测是否被任意线程占有 | 支持，isLocked() | 不支持 |
| 条件锁 | 可支持多个条件，condition.await()，condition.signal()，condition.signalAll() | 只支持一个，obj.wait()，obj.notify()，obj.notifyAll() |
对比测试
在测试以前，咱们先预想一下结果，随着线程数的不断增长，ReentrantLock（fair）、ReentrantLock（unfair）、synchronized三者的效率怎样呢？线程
我猜想应该是ReentrantLock（unfair）> synchronized > ReentrantLock（fair）。code
究竟是不是这样呢？对象
直接上测试代码：（为了全面对比，彤哥这里把AtomicInteger和LongAdder也拿来一块儿对比了）
public class ReentrantLockVsSynchronizedTest {
public static AtomicInteger a = new AtomicInteger(0);
public static LongAdder b = new LongAdder();
public static int c = 0;
public static int d = 0;
public static int e = 0;
public static final ReentrantLock fairLock = new ReentrantLock(true);
public static final ReentrantLock unfairLock = new ReentrantLock();
public static void main(String[] args) throws InterruptedException {
System.out.println("-------------------------------------");
testAll(1, 100000);
System.out.println("-------------------------------------");
testAll(2, 100000);
System.out.println("-------------------------------------");
testAll(4, 100000);
System.out.println("-------------------------------------");
testAll(6, 100000);
System.out.println("-------------------------------------");
testAll(8, 100000);
System.out.println("-------------------------------------");
testAll(10, 100000);
System.out.println("-------------------------------------");
testAll(50, 100000);
System.out.println("-------------------------------------");
testAll(100, 100000);
System.out.println("-------------------------------------");
testAll(200, 100000);
System.out.println("-------------------------------------");
testAll(500, 100000);
System.out.println("-------------------------------------");
// testAll(1000, 1000000);
System.out.println("-------------------------------------");
testAll(500, 10000);
System.out.println("-------------------------------------");
testAll(500, 1000);
System.out.println("-------------------------------------");
testAll(500, 100);
System.out.println("-------------------------------------");
testAll(500, 10);
System.out.println("-------------------------------------");
testAll(500, 1);
System.out.println("-------------------------------------");
}
public static void testAll(int threadCount, int loopCount) throws InterruptedException {
testAtomicInteger(threadCount, loopCount);
testLongAdder(threadCount, loopCount);
testSynchronized(threadCount, loopCount);
testReentrantLockUnfair(threadCount, loopCount);
// testReentrantLockFair(threadCount, loopCount);
}
public static void testAtomicInteger(int threadCount, int loopCount) throws InterruptedException {
long start = System.currentTimeMillis();
CountDownLatch countDownLatch = new CountDownLatch(threadCount);
for (int i = 0; i < threadCount; i++) {
new Thread(() -> {
for (int j = 0; j < loopCount; j++) {
a.incrementAndGet();
}
countDownLatch.countDown();
}).start();
}
countDownLatch.await();
System.out.println("testAtomicInteger: result=" + a.get() + ", threadCount=" + threadCount + ", loopCount=" + loopCount + ", elapse=" + (System.currentTimeMillis() - start));
}
public static void testLongAdder(int threadCount, int loopCount) throws InterruptedException {
long start = System.currentTimeMillis();
CountDownLatch countDownLatch = new CountDownLatch(threadCount);
for (int i = 0; i < threadCount; i++) {
new Thread(() -> {
for (int j = 0; j < loopCount; j++) {
b.increment();
}
countDownLatch.countDown();
}).start();
}
countDownLatch.await();
System.out.println("testLongAdder: result=" + b.sum() + ", threadCount=" + threadCount + ", loopCount=" + loopCount + ", elapse=" + (System.currentTimeMillis() - start));
}
public static void testReentrantLockFair(int threadCount, int loopCount) throws InterruptedException {
long start = System.currentTimeMillis();
CountDownLatch countDownLatch = new CountDownLatch(threadCount);
for (int i = 0; i < threadCount; i++) {
new Thread(() -> {
for (int j = 0; j < loopCount; j++) {
fairLock.lock();
// 消除try的性能影响
// try {
c++;
// } finally {
fairLock.unlock();
// }
}
countDownLatch.countDown();
}).start();
}
countDownLatch.await();
System.out.println("testReentrantLockFair: result=" + c + ", threadCount=" + threadCount + ", loopCount=" + loopCount + ", elapse=" + (System.currentTimeMillis() - start));
}
public static void testReentrantLockUnfair(int threadCount, int loopCount) throws InterruptedException {
long start = System.currentTimeMillis();
CountDownLatch countDownLatch = new CountDownLatch(threadCount);
for (int i = 0; i < threadCount; i++) {
new Thread(() -> {
for (int j = 0; j < loopCount; j++) {
unfairLock.lock();
// 消除try的性能影响
// try {
d++;
// } finally {
unfairLock.unlock();
// }
}
countDownLatch.countDown();
}).start();
}
countDownLatch.await();
System.out.println("testReentrantLockUnfair: result=" + d + ", threadCount=" + threadCount + ", loopCount=" + loopCount + ", elapse=" + (System.currentTimeMillis() - start));
}
public static void testSynchronized(int threadCount, int loopCount) throws InterruptedException {
long start = System.currentTimeMillis();
CountDownLatch countDownLatch = new CountDownLatch(threadCount);
for (int i = 0; i < threadCount; i++) {
new Thread(() -> {
for (int j = 0; j < loopCount; j++) {
synchronized (ReentrantLockVsSynchronizedTest.class) {
e++;
}
}
countDownLatch.countDown();
}).start();
}
countDownLatch.await();
System.out.println("testSynchronized: result=" + e + ", threadCount=" + threadCount + ", loopCount=" + loopCount + ", elapse=" + (System.currentTimeMillis() - start));
}
}
运行这段代码，你会发现结果大大出乎意料，真的是不测不知道，一测吓一跳，运行后发现如下规律：
随着线程数的不断增长，synchronized的效率居然比ReentrantLock非公平模式要高！
彤哥的电脑上大概是高3倍左右，个人运行环境是4核8G，java版本是8，请你们必定要在本身电脑上运行一下，而且最好能给我反馈一下。
彤哥又使用Java7及如下的版本运行了，发如今Java7及如下版本中synchronized的效率确实比ReentrantLock的效率低一些。
总结
（1）synchronized是Java原生关键字锁；
（2）ReentrantLock是Java语言层面提供的锁；
（3）ReentrantLock的功能很是丰富，解决了不少synchronized的局限性；
（4）至于在非公平模式下，ReentrantLock与synchronized的效率孰高孰低，彤哥给出的结论是随着Java版本的不断升级，synchronized的效率只会愈来愈高；
彩蛋
既然ReentrantLock的功能更丰富，并且效率也不低，咱们是否是能够放弃使用synchronized了呢？
答：我认为不是。由于synchronized是Java原生支持的，随着Java版本的不断升级，Java团队也是在不断优化synchronized，因此我认为在功能相同的前提下，最好仍是使用原生的synchronized关键字来加锁，这样咱们就能得到Java版本升级带来的免费的性能提高的空间。
另外，在Java8的ConcurrentHashMap中已经把ReentrantLock换成了synchronized来分段加锁了，这也是Java版本不断升级带来的免费的synchronized的性能提高。
推荐阅读
欢迎关注个人公众号“彤哥读源码”，查看更多源码系列文章, 与彤哥一块儿畅游源码的海洋。
相关文章
- 1. 死磕 java同步系列之ReentrantLock VS synchronized——结果可能跟你想的不同
- 2. 死磕 java同步系列之开篇
- 3. 死磕 java同步系列之synchronized解析
- 4. 死磕 java同步系列之终结篇
- 5. 死磕Java——ReentrantLock
- 6. 死磕 java同步系列之ReentrantLock源码解析（二）——条件锁
- 7. 死磕 java同步系列之JMM（Java Memory Model）
- 8. 死磕 java同步系列之AQS终篇（面试）
- 9. 死磕源码系列（ReentrantLock）
- 10. 死磕 java同步系列之CountDownLatch源码解析
- 更多相关文章...
- • Lua 协同程序(coroutine) - Lua 教程
- • Spring体系结构详解 - Spring教程
- • SpringBoot中properties文件不能自动提示解决方法
- • 互联网组织的未来：剖析GitHub员工的任性之源
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. 死磕 java同步系列之ReentrantLock VS synchronized——结果可能跟你想的不同
- 2. 死磕 java同步系列之开篇
- 3. 死磕 java同步系列之synchronized解析
- 4. 死磕 java同步系列之终结篇
- 5. 死磕Java——ReentrantLock
- 6. 死磕 java同步系列之ReentrantLock源码解析（二）——条件锁
- 7. 死磕 java同步系列之JMM（Java Memory Model）
- 8. 死磕 java同步系列之AQS终篇（面试）
- 9. 死磕源码系列（ReentrantLock）
- 10. 死磕 java同步系列之CountDownLatch源码解析