可重入锁是对象级锁还是类级锁？

Question

我在许多关于可重入锁的教程中看到，它们创建一个新的可重入锁并注入资源，可重入锁的锁定和解锁在try/finally块中调用。我不理解这个锁和线程中使用的资源之间的连接。下面是一个关于可重入锁的教程示例

资源代码

public class Resource {

    public void doSomething(){
        //do some operation, DB read, write etc
    }
    
    public void doLogging(){
        //logging, no need for thread safety
    }
}

线程声明代码中使用的资源

public class ConcurrencyLockExample implements Runnable{

    private Resource resource;
    private Lock lock;
    
    public ConcurrencyLockExample(Resource r){
        this.resource = r;
        this.lock = new ReentrantLock();
    }
    
    @Override
    public void run() {
        try {
            if(lock.tryLock(10, TimeUnit.SECONDS)){
            resource.doSomething();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            //release lock
            lock.unlock();
        }
        resource.doLogging();
    }
}

有人能解释一下，这是如何防止多个线程同时访问给定的资源，从而导致争用情况的？？？这个可重入锁是在资源中创建对象级锁还是类级锁？？？

Answer 1

在某种意义上，可重入锁既不是类级锁，也不是对象级锁。从更实际的意义上讲，这与它们中的任何一个都是一样的。

实际上，您应该忘记“类级”和“对象级”锁定。这些都不是有用的区别。

您可以在同步（锁）{…}中使用任何对象作为锁 块。“对象级”锁定仅仅意味着，在类C的某个方法中，您选择的对象是该类的一个实例；“class level”表示您选择使用C.class作为锁对象。

但是，您也可以使用其他对象，*和同步（锁定）的行为方式与为锁定选择的对象相同。

*这是一种经验丰富的软件开发人员经常使用的模式：

class C {
    private final Object lock = new Object();

    public MyType myMethod(...) {
        ...
        synchronized(lock) {
            ...
        }
        ...
    }
}

在上述私有对象而不是C的实例上同步的优势是微妙的。简而言之，它可以防止使用类C的某些应用程序的作者使用C的实例作为锁。如果两个不同的作者选择使用同一个实例作为锁，可能会出现不可预见的交互（例如，在最坏的情况下，死锁。）