Java Lock.tryLock（）：执行不同任务的线程？

我试图理解Java中的多线程，使用 作为

java.util.concurrent.*

的一部分添加的功能。首先，有一个

lock

的概念，线程可以尝试获取它；如果线程无法获取，它可以执行其他任务

这一点我在一些书的在线资料中也读过，但从未见过他们在现实中实现的任何东西。如果一个线程不能获得锁，它怎么可能执行其他任务；难道一根线不应该做一件“工作”吗？如果它能/不能获得锁，它怎么能有多个逻辑执行

是否有任何我可以参考、理解、强化概念的实际实施；否则就显得太抽象了，如何在现实生活中实现

---

有什么解释吗？

很难找到现实生活中的例子，因为通常情况下，您不会将软件设计为使用

tryLock（）

。javadoc中给出的示例如下：

Lock lock = ...;
if (lock.tryLock()) {
  try {
    // manipulate protected state
  } finally {
    lock.unlock();
  }
} else {
  // perform alternative actions
}

但是你不会那样设计你的软件，是吗？如果锁永远（或几乎永远）不可用，会如何影响您的程序？如果它总是可用呢？你有一种方法，可以根据纯粹的机会做两件事中的一件。这不是一个好的设计，它增加了随机性和复杂性

好吧，这不是你决定用的东西，因为它很优雅。它有什么好处

假设您继承了一个由设计的遗留项目，并且该项目存在严重的死锁问题。它的

synchronized

方法层出不穷，需要每周至少启动一次，因为它会被锁定。首先，将所有的

synchronized

方法转换为使用

Lock

。现在您不再在

synchronized

上永久阻塞，而是可以使用来超时并防止死锁

现在，您已经解决了导致死锁的重新启动问题，但由于您要花费时间等待，因此它仍然不是最优的。通过额外的重构，您可以设法减少锁，但不幸的是，您现在还不能做正确的事情。您的最终代码如下所示，其中使用

tryLock（）

获取内部锁，或者释放外部锁以防止死锁：

Lock outerLock = ...;
outerLock.lock();  // Here we block freely
try {
   Lock innerLock = ...;
   if (innerLock.tryLock()) {  // Here we risk deadlock, we'd rather "fail-fast"
     try {
       doSomethingProtectedByLocks();
     } finally {
       innerLock.unlock();
     }
   } else {
     throw new OperationFailedException(); // Signal the calling code to retry
   }   
} finally {
   outerLock.unlock();
}

---

我认为问题主要在于措辞。Javadoc讨论了基于是否获得锁而执行的“操作”（如解锁外部锁），但是很容易理解，就好像线程将有两个由锁状态决定的独立职责一样。

很难找到真实的示例，因为通常您不会将软件设计为使用

tryLock（）

。javadoc中给出的示例如下：

Lock lock = ...;
if (lock.tryLock()) {
  try {
    // manipulate protected state
  } finally {
    lock.unlock();
  }
} else {
  // perform alternative actions
}

但是你不会那样设计你的软件，是吗？如果锁永远（或几乎永远）不可用，会如何影响您的程序？如果它总是可用呢？你有一种方法，可以根据纯粹的机会做两件事中的一件。这不是一个好的设计，它增加了随机性和复杂性

好吧，这不是你决定用的东西，因为它很优雅。它有什么好处

假设您继承了一个由设计的遗留项目，并且该项目存在严重的死锁问题。它的

synchronized

方法层出不穷，需要每周至少启动一次，因为它会被锁定。首先，将所有的

synchronized

方法转换为使用

Lock

。现在您不再在

synchronized

上永久阻塞，而是可以使用来超时并防止死锁

现在，您已经解决了导致死锁的重新启动问题，但由于您要花费时间等待，因此它仍然不是最优的。通过额外的重构，您可以设法减少锁，但不幸的是，您现在还不能做正确的事情。您的最终代码如下所示，其中使用

tryLock（）

获取内部锁，或者释放外部锁以防止死锁：

Lock outerLock = ...;
outerLock.lock();  // Here we block freely
try {
   Lock innerLock = ...;
   if (innerLock.tryLock()) {  // Here we risk deadlock, we'd rather "fail-fast"
     try {
       doSomethingProtectedByLocks();
     } finally {
       innerLock.unlock();
     }
   } else {
     throw new OperationFailedException(); // Signal the calling code to retry
   }   
} finally {
   outerLock.unlock();
}

---

我认为问题主要在于措辞。Javadoc讨论了根据是否获得锁来执行的“操作”（如解锁外部锁），但很容易理解，就好像线程有两个由锁状态决定的独立职责一样。

虽然可以实现这样的线程，但实际上它并没有真正发生。通常，当一个线程无法获得锁时，它只会等待（不做任何事情），直到它能够获得锁为止。至于如何做到这一点，如果你继续搜索

tryLock（）

，你可以找到现实生活中的例子，这与使用标准条件逻辑（即if语句）没有什么不同。@ciousmind，我记不起来了。我可以想象它会是什么样子，但我正在努力思考一个有效的用例。如果您有两个不同的任务共享一个线程，一个需要锁，另一个不需要锁，我看不出对每个任务使用线程有什么好处。非锁定任务还必须能够处理可能永远不会执行的问题，这也是不寻常的。虽然可以实现这样的线程，但实际上它并没有真正发生。通常，当一个线程无法获得锁时，它只会等待（不做任何事情），直到它能够获得锁为止。至于如何做到这一点，如果你继续搜索

tryLock（）

，你可以找到现实生活中的例子，这与使用标准条件逻辑（即if语句）没有什么不同。@ciousmind，我记不起来了。我可以想象它会是什么样子，但我正在努力思考一个有效的用例。如果您有两个不同的任务共享一个线程，一个需要锁，另一个不需要锁，我看不出对每个任务使用线程有什么好处。非锁定任务也必须可以，因为可能永远不会被执行，这也是不寻常的。这是我能想到的最不复杂的情况。你并不总是有足够的吸引力说“让我们重写整件事”，所以