互斥同步器 ReentrantLock和内部锁 synchronized 的性能对比

本文通过实验对比了ReentrantLock(公平与非公平)及synchronized关键字在多线程环境下的性能差异。结果显示,在高并发场景下,非公平ReentrantLock表现出更好的性能。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

ReentrantLock是jdk5引入的新的锁机制,它与内部锁(synchronize)相同的并发性和内存语义,比如可重入加锁语义。在中等或者更高负荷下,ReentrantLock有更好的性能,并且拥有可轮询和可定时的请求锁等高级功能。这个程序简单对比了ReentrantLock公平锁、ReentrantLock非公平锁以及内部锁的性能,从结果上看,非公平的 ReentrantLock表现最好。内部锁也仅仅是实现统计意义上的公平,结果也比公平的ReentrantLock好上很多。这个程序仅仅是计数,启动N个线程,对同一个Counter进行递增,显然,这个递增操作需要同步以保证原子性,采用不同的锁来实现同步,然后查看结果。
Counter接口:
  1. package net.rubyeye.concurrency.chapter13;

  2. public interface Counter {
  3.     public long getValue();

  4.     public void increment();

  5. }
复制代码
然后,首先使用我们熟悉的synchronize来实现同步:
  1. package net.rubyeye.concurrency.chapter13;

  2. public class SynchronizeBenchmark implements Counter {
  3.     private long count = 0;

  4.     public long getValue() {
  5.         return count;
  6.     }

  7.     public synchronized void increment() {
  8.         count++;
  9.     }
  10. }
复制代码
采用ReentrantLock的版本,切记要在finally中释放锁,这是与synchronize使用方式最大的不同,内部锁jvm会自动帮你释放锁,而ReentrantLock需要你自己来处理。
  1. package net.rubyeye.concurrency.chapter13;

  2. import java.util.concurrent.locks.Lock;
  3. import java.util.concurrent.locks.ReentrantLock;

  4. public class ReentrantLockBeanchmark implements Counter {

  5.     private volatile long count = 0;

  6.     private Lock lock;

  7.     public ReentrantLockBeanchmark() {
  8.         // 使用非公平锁,true就是公平锁
  9.         lock = new ReentrantLock(false);
  10.     }

  11.     public long getValue() {
  12.         // TODO Auto-generated method stub
  13.         return count;
  14.     }

  15.     public void increment() {
  16.         lock.lock();
  17.         try {
  18.             count++;
  19.         } finally {
  20.             lock.unlock();
  21.         }
  22.     }

  23. }
复制代码
写一个测试程序,使用CyclicBarrier来等待所有任务线程创建完毕以及所有任务线程计算完成,清单如下:
  1. package net.rubyeye.concurrency.chapter13;

  2. import java.util.concurrent.CyclicBarrier;

  3. public class BenchmarkTest {
  4.     private Counter counter;

  5.     private CyclicBarrier barrier;

  6.     private int threadNum;

  7.     public BenchmarkTest(Counter counter, int threadNum) {
  8.         this.counter = counter;
  9.         barrier = new CyclicBarrier(threadNum + 1); //关卡计数=线程数+1
  10.         this.threadNum = threadNum;
  11.     }

  12.     public static void main(String args[]) {
  13.         new BenchmarkTest(new SynchronizeBenchmark(), 5000).test();
  14.         //new BenchmarkTest(new ReentrantLockBeanchmark(), 5000).test();
  15.         //new BenchmarkTest(new ReentrantLockBeanchmark(), 5000).test();   
  16.     }

  17.     public void test() {
  18.         try {
  19.             for (int i = 0; i < threadNum; i++) {
  20.                 new TestThread(counter).start();
  21.             }
  22.             long start = System.currentTimeMillis();
  23.             barrier.await(); // 等待所有任务线程创建
  24.             barrier.await(); // 等待所有任务计算完成
  25.             long end = System.currentTimeMillis();
  26.             System.out.println("count value:" + counter.getValue());
  27.             System.out.println("花费时间:" + (end - start) + "毫秒");
  28.         } catch (Exception e) {
  29.             throw new RuntimeException(e);
  30.         }
  31.     }

  32.     class TestThread extends Thread {
  33.         private Counter counter;

  34.         public TestThread(final Counter counter) {
  35.             this.counter = counter;
  36.         }

  37.         public void run() {
  38.             try {
  39.                 barrier.await();
  40.                 for (int i = 0; i < 100; i++)
  41.                     counter.increment();
  42.                 barrier.await();
  43.             } catch (Exception e) {
  44.                 throw new RuntimeException(e);
  45.             }
  46.         }
  47.     }
  48. }
复制代码
分别测试一下,

将启动的线程数限定为500,结果为:
公平ReentrantLock:      210 毫秒
非公平ReentrantLock :   39  毫秒
内部锁:                          39 毫秒

将启动的线程数限定为1000,结果为:
公平ReentrantLock:      640 毫秒
非公平ReentrantLock :   81 毫秒
内部锁:                           60 毫秒

线程数不变,test方法中的循环增加到1000次,结果为:
公平ReentrantLock:      16715 毫秒
非公平ReentrantLock :   168 毫秒
内部锁:                           639  毫秒

将启动的线程数增加到2000,结果为:
公平ReentrantLock:      1100 毫秒
非公平ReentrantLock:   125 毫秒
内部锁:                           130 毫秒

将启动的线程数增加到3000,结果为:
公平ReentrantLock:      2461 毫秒
非公平ReentrantLock:   254 毫秒
内部锁:                           307 毫秒

启动5000个线程,结果如下:
公平ReentrantLock:      6154  毫秒
非公平ReentrantLock:   623   毫秒
内部锁:                           720 毫秒

非公平ReentrantLock和内部锁的差距,在jdk6上应该缩小了,据说jdk6的内部锁机制进行了调整。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值