ReentrantLock：单线程应用程序中的锁定/解锁速度

Question

我正在使用一些 ReentrantLock 来同步跨多个线程对列表的访问。我只是

try {
   lock.lock();
   ... modify list here
} finally {
   lock.unlock();
}

到处写一个通用的。我只是注意到，代码中的大多数列表将仅由单个（gui 调度）线程使用。

现在我不确定在这些情况下是否应该删除锁，因为它可能会加快我的代码速度。 ReentrantLock 有多快？如果线程本身是锁的“先前所有者”，即使他解锁（）它，lock（）操作是否会更快？

Answer 1

不管它有多快，它肯定会比不加锁慢，哪怕只是慢一点。我个人更喜欢正确性而不是速度增益（速度增益不会很多），并保持代码原样（特别是如果它已经经过测试），除非您已经确定“锁定”是一个瓶颈。

Answer 2

3件事：

• lock.lock()应该在try块之外。

• 如果你运行在单核CPU上，锁定是非常便宜的。然后，根据 CPU 架构，获取/释放可能会很便宜，也可能不太便宜。 Nehalem+ 还不错。

• 如果您不需要其他任何东西的锁，synchronized 可能是更好的方法，因为 JVM 可以在单线程应用程序中粗化监视器和/或偏向 lock()em。同样，偏向锁的性能因 CPU 架构而异。

Answer 3

如果没有争用，获取和释放锁的成本相当低。我想说你不必担心性能影响。

Answer 4

我真的不明白你的应用程序是单线程还是多线程。标题说的是一件事，从正文我们可以推断出另一件事。我假设您正在使用多个线程（否则，这个问题就没有意义——为什么要在……少于 2 个线程之间使用同步？！）。

可能存在比性能更大的问题。 可见性。

您没有提供有关 ...修改列表... 的代码部分的任何详细信息，但是了解详细信息非常重要：取决于您的操作方式也就是说，如果您删除锁定，可能会发生的情况是：一个线程修改了列表，而另一个线程永远不会看到这些修改（或看到部分、很可能不一致的修改）。

您似乎缺少的同步方面是，除非使用某些特定的构造（锁/易失性变量/最终字段），否则无法保证一个线程会看到另一个线程对内存所做的操作。

在这种情况下，你的保证是由锁给出的：当线程 T1 获取锁 L 时，保证它将看到线程 T2 在 T2 释放锁 L 之前对内存所做的所有修改。

   T2            T1
acquires L
modifies a
modifies b
releases L
modifies c    acquires L
              reads a
              reads b
              reads c
              releases L

在这种情况下，可以保证 T1 会看到 a 和 b 的正确值，但不能保证在读取 c 时会看到什么。

如果您取出锁，请确保您的数据结构是线程安全的，并且如果包含的数据（即列表中的对象）不是线程安全的，请确保在每次修改和后续数据检索之间触发happens-before关系，否则会发生不好的事情。

Answer 5

我编写的测试代码显示 ReentrantLock 比单线程上的同步慢 10 倍。

由于我的自定义 TCP 协议解码器花费了 300 ns，因此锁定速度很重要。

JDK 14：

• ReentrantLock：32.34 ns
• 同步：3.48 ns

JDK 11：

• ReentrantLock：30.3 ns
• 同步：3.7 ns

我的测试：

public class MyTest
{
    private ReentrantLock lock = new ReentrantLock();
    private String s;

    @Test
    public void test()
    {
        long t1 = System.currentTimeMillis();
        for (int i = 0; i < 100_000_000; i++) {
            lock.lock();
            try {
                //
            } finally {
                lock.unlock();
            }
        }
        long t2 = System.currentTimeMillis();
        long d1 = t2 - t1;
        System.out.println("ReentrantLock: " + d1 / 100f + " ns");

        t1 = System.currentTimeMillis();
        for (int i = 0; i < 100_000_000; i++) {
            m1();
        }
        t2 = System.currentTimeMillis();
        long d2 = t2 - t1;
        t1 = System.currentTimeMillis();
        for (int i = 0; i < 100_000_000; i++) {
            m2();
        }
        t2 = System.currentTimeMillis();
        long d3 = t2 - t1;
        long d4 = d2 - d3;
        System.out.println("synchronized: " + d4 / 100f + " ns");
    }

    public synchronized void m1() {
        s = "1";
        s = "2";
        s = "3";
    }

    public void m2() {
        s = "1";
        s = "2";
        s = "3";
    }
}