对于特定的线程安全数据结构，我需要保护对中心数据结构（即字节数组）的访问。在本例中，我选择使用reentrantlocks是因为它的公平性策略以及创建多个条件的高级功能。
并发条件很复杂，如下所示：
必须以独占方式保护中心字节数组（即一次一个线程）。
两个访问方法（foo和bar）必须能够同时运行（如果它们尝试访问中心字节数组，则在内部阻塞）。
对任何方法（foo和bar）的调用都必须是独占的（即，来自不同线程的多个foo调用将导致一个线程阻塞）。
在我最初的实现中，我选择实现两个嵌套锁，如下所示：

ReentrantLock lockFoo = new ReentrantLock(true);
ReentrantLock lockCentral = new ReentrantLock(true);

Condition centralCondition = lockCentral.newCondition();

public void foo(){
    // thread-safe processing code here

    lockFoo.lock();        
    lockCentral.lock();

    try{
        // accessing code here

        try{
            // waits upon some condition for access
            while(someCondition){
                centralCondition.await();
            }
        }catch(InterruptedException ex){
            // handling code here
        }

        // more processing
    }finally{
        lockCentral.unlock();
        lockFoo.unlock();
    }
}

结构在方法上是等价的 bar ，只需使用另一个锁对象 lockBar . 此外，为了简单起见，代码将我更复杂的多条件等待和信号简化为单个条件。
使用这个，我不禁觉得代码似乎不必要的复杂和晦涩，不仅有两个锁嵌套，他们共享一个尝试最后，更不用说如何 lockCentral 可多次释放和重新获取 lockFoo 始终保持。
相反，我试图重新组织外部锁( lockFoo 以及 lockBar )作为…的条件 lockCentral 相反，如下所示：

ReentrantLock lockCentral = new ReentrantLock(true);

Condition fooCondition = lockCentral.newCondition();
Condition centralCondition = lockCentral.newCondition();

boolean isInFoo = false;

public void foo(){
    // thread-safe processing code here

    lockCentral.lock();

    try{
        // implement method exclusiveness via fooCondition

        try{
            while(isInFoo){
                fooCondition.await();
            }

            isInFoo = true;
        }catch(InterruptedException ex){
            return;
        }

        // accessing code here

        try{
            // waits upon some condition for access
            while(someCondition){
                centralCondition.await();
            }
        }catch(InterruptedException ex){
            // handling code here
        }

        // more processing
    }finally{
        isInFoo = false;
        fooCondition.signal();

        lockCentral.unlock();
    }
}

经过一番检查，我无法决定前者是更好的主意还是后者（特别是在包含随机布尔值的情况下）。简化代码的想法似乎导致了更长的代码，在这种情况下非常违反直觉。
是否有一些惯例或令人信服的理由来论证：
每个锁定上下文使用一个锁（前一个代码，其中不同的锁定原因共享不同的锁）。
每个锁资源使用一个锁（后一个代码，其中要保护的中心结构使用一个锁，其他所有内容都作为访问所述结构的条件实现）。