java - 为什么不在 java 中使用 try with lock 呢？

Question

我读过 this topic ，还有这个 blog article关于 尝试使用资源 锁，因为这个问题突然出现在我的脑海中。但实际上，我更喜欢尝试使用锁，我的意思是没有锁实例化。它会让我们从冗长的

lock.lock();
try {
    //Do some synchronized actions throwing Exception 
} finally {
    //unlock even if Exception is thrown
    lock.unlock();
}

宁愿看起来像:

? implements Unlockable lock ;
...
try(lock) //implicitly calls lock.lock() 
{
    //Do some synchronized actions throwing Exception 
} //implicitly calls finally{lock.unlock();}

所以它不会是 TWR，而只是一些样板清洁。

您是否有任何技术理由建议描述为什么这不是一个合理的想法？

编辑:为了阐明我的建议与简单的synchronized(lock){} block 之间的区别，请检查此代码段:

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;


public class Test {

        public static void main(String[] args) {
                ReentrantLock locker =new ReentrantLock();
                Condition condition = locker.newCondition();
                Thread t1 = new Thread("Thread1") {
                        @Override
                        public void run(){
                                synchronized(locker){
                                        try {
                                                condition.await();
                                        } catch (InterruptedException e) {
                                                Thread.currentThread().interrupt();
                                        }
                                        System.out.println("Thread1 finished");
                                }
                        }
                } ;
                Thread t2 = new Thread("Thread2") {
                        @Override
                        public void run(){
                                synchronized(locker){
                                        Thread.yield();
                                        condition.signal();
                                        System.out.println("blabla2");
                                }
                        }
                } ;
                t1.start();
                t2.start();
        }

}

执行将导致 IllegalMonitorStateException，因此不会在 synchronized block 中隐式调用 lock() 和 unlock() 方法。

Answer 1

如果你不得不处理像这样的简单情况，其中锁定/解锁模式被限制在像这样的狭窄范围内，你可能不想使用更复杂的 Lock。类，可能应该只使用 synchronized 关键字。话虽这么说，如果出于某种原因您需要使用更复杂的 Lock 对象，那么围绕实现 AutoCloseable 的 Lock 创建一个包装器应该相对简单。界面能够做到这一点。示例:

class AutoUnlock implements AutoCloseable {
  private final Lock lock;

  public static AutoUnlock lock(Lock lock) {
    lock.lock();
    return new AutoUnlock(lock);
  }

  public static AutoUnlock tryLock(Lock lock) {
    if (!lock.tryLock()) {
       throw new LockNotAcquiredException();
    }
    return new AutoUnlock(lock);
  }

  @Override
  public void close() {
    lock.unlock();
  }

  private AutoUnlock(Lock lock) {
    this.lock = lock;
  }
}

使用上面的包装器，您可以执行以下操作:

try (AutoUnlock autoUnlock = AutoUnlock.lock(lock)) {
  // ... do whatever that requires the lock ...
}

也就是说，Lock 类通常用于非常复杂的锁定场景，在这些场景中这不是特别有用。例如，Lock 对象可能在一个类的一个函数中被锁定，然后在另一个函数中解锁(例如，锁定数据库中的一行以响应传入的远程过程调用，然后解锁该行以响应稍后的 RPC)，因此，拥有这样的包装器或使 Lock AutoCloseable 本身对于它的实际使用方式来说用途有限。对于更简单的场景，更常见的是只使用现有的并发数据结构或使用同步。