java: 执行者 +任务 +锁

Question

假设我有一个 ExecutorService（可以是线程池，因此涉及并发），它在不同时间（定期或响应某些其他条件）执行任务。要执行的任务如下：

• 如果该任务已经在进行中，则不执行任何操作（并让先前运行的任务完成）。
• 如果此任务尚未进行，请运行算法 X，这可能需要很长时间。

我正在尝试想一个方法来实现这一点。它应该类似于：

Runnable task = new Runnable() {
   final SomeObj inProgress = new SomeObj();
   @Override public void run() {
       if (inProgress.acquire())
       {
          try
          {
             algorithmX();
          }
          finally
          {
             inProgress.release();
          }
       }
   }
}

// re-use this task object whenever scheduling the task with the executor

其中 SomeObj 是 ReentrantLock （获取 = tryLock() 并释放 = unlock()） 或 AtomicBoolean 或其他东西，但是我不确定是哪一个。我这里需要一个ReentrantLock吗？ （也许我想要一个不可重入的锁，以防 algorithmX() 导致此任务递归运行！）或者 AtomicBoolean 就足够了吗？

---

编辑：对于不可重入锁，这合适吗？

Runnable task = new Runnable() {
   boolean inProgress = false;
   final private Object lock = new Object();
   /** try to acquire lock: set inProgress to true, 
    *  return whether it was previously false
    */ 
   private boolean acquire() {
      synchronized(this.lock)
      {
         boolean result = !this.inProgress;
         this.inProgress = true;
         return result;
      }
   }
   /** release lock */
   private void release() {
      synchronized(this.lock)
      {
         this.inProgress = false;
      }
   }
   @Override public void run() {
       if (acquire())
       {
          // nobody else is running! let's do algorithmX()
          try
          {
             algorithmX();
          }
          finally
          {
             release();
          }
       }
       /* otherwise, we are already in the process of 
        * running algorithmX(), in this thread or in another,
        * so don't do anything, just return control to the caller.
        */
   }
}

Answer 1

您建议的锁实现很弱，因为有人很容易不当使用它。

下面是一个更有效的实现，与您的实现具有相同的不当使用弱点：

   AtomicBoolean inProgress = new AtomicBoolean(false)
   /* Returns true if we acquired the lock */
   private boolean acquire() {
       return inProgress.compareAndSet(false, true);
   }
   /** Always release lock without determining if we in fact hold it */
   private void release() {
       inProgress.set(false);
   }

Answer 2

您的第一段代码看起来相当不错，但如果您担心 algorithmX 递归调用该任务，我建议您使用 java.util.concurrent.Semaphore 作为同步对象，而不是ReentrantLock。例如：

Runnable task = new Runnable() {
   final Semaphore lock = new Semaphore( 1 );
   @Override public void run() {
       if (lock.tryAcquire())
       {
          try
          {
             algorithmX();
          }
          finally
          {
             lock.release();
          }
       }
   }
}

特别注意尝试获取的使用。如果获取锁失败，则不会运行algorithmX。

Answer 3

ReentrantLock 对我来说似乎很好。我觉得使用 AtomicInteger 手动创建锁有趣的唯一情况是，如果您的 algorithmX 非常短，而这不是您的情况。

Answer 4

我认为选择正确的锁实现的秘诀是：
* 如果此任务已在进行中，则不执行任何操作（并让先前运行的任务完成）。

在这种情况下“什么也不做”是什么意思？运行algorithmX完成后，线程应该阻塞并重试执行吗？。如果是这种情况，应使用 semaphore.acquire 而不是 tryAcquire，并且 AtomicBoolean 解决方案将无法按预期工作。