如何确保该方法仅执行一次并且仅从一个线程执行？

Question

我有一个下面的方法，我想在以下条件下执行：

• 这个方法应该只执行一次。一旦它被执行，它就不能再次执行，所以如果有人试图再次执行，它应该通过记录一些有用的错误消息already executed 或任何有用的东西来返回。
• 而且它只能由一个线程执行。那么如果多个线程在调用下面的方法，那么它应该只被一个线程调用，其他线程应该等待初始化完成？

下面是我的方法：

  public void initialize() {
    List<Metadata> metadata = getMetadata(true);
    List<Process> process = getProcess();
    if (!metadata.isEmpty() && !process.isEmpty()) {
        Manager.setAllMetadata(metadata, process);
    }
    startBackgroundThread();
  }

这可能吗？我正在使用 Java 7。

Answer 1

@ShayHaned 的解决方案使用锁定。您可以通过AtomicBoolean 提高效率，例如：

AtomicBoolean wasRun = new AtomicBoolean(false);
CountDownLatch initCompleteLatch = new CountDownLatch(1);

public void initialize() {
  if (!wasRun.getAndSet(true)) {
      List<Metadata> metadata = getMetadata(true);
      List<Process> process = getProcess();
      if (!metadata.isEmpty() && !process.isEmpty()) {
          Manager.setAllMetadata(metadata, process);
      }
      startBackgroundThread();
      initCompleteLatch.countDown();
  } else {
      log.info("Waiting to ensure initialize is done.");
      initCompleteLatch.await();
      log.warn("I was already run");
  }
}

以上假设您不必等待startBackgroundThread 中的工作完成。如果这样做，解决方案将变为：

AtomicBoolean wasRun = new AtomicBoolean(false);
CountDownLatch initCompleteLatch = new CountDownLatch(1);

public void initialize() {
  if (!wasRun.getAndSet(true)) {
      List<Metadata> metadata = getMetadata(true);
      List<Process> process = getProcess();
      if (!metadata.isEmpty() && !process.isEmpty()) {
          Manager.setAllMetadata(metadata, process);
      }
      // Pass the latch to startBackgroundThread so it can
      // call countDown on it when it's done.
      startBackgroundThread(initCompleteLatch);
  } else {
      log.info("Waiting to ensure initialize is done.");
      initCompleteLatch.await();
      log.warn("I was already run");
  }
}

这样做的原因是AtomicBoolean.getAndSet(true) 将在一个原子操作中返回先前设置的值并使新值成为true。因此，第一个访问您的方法的线程将返回 false（因为变量已初始化为 false），并且它将自动将其设置为 true。由于第一个线程返回了错误，它将采用if 语句中的第一个分支，并且您的初始化将发生。任何其他调用都会发现 wasRun.getAndSet 返回 true，因为第一个线程将其设置为 true，因此他们将采用第二个分支，您将获得所需的日志消息。

CountDownLatch 被初始化为 1，因此除第一个线程之外的所有线程都在其上调用 await。它们将阻塞，直到第一个线程调用countDown，这会将计数设置为 0，从而释放所有等待的线程。

Answer 2

您可以为您的方法创建一个静态标志，该标志只有在调用该方法时才会更改。使用静态标志背后的想法是它不属于它属于类的实例，这意味着从同一个类创建的所有线程都可以访问相同的标志值，因此一旦标志的布尔值在第一次调用后更改方法所有其他线程将被 if else 条件语句绕过。

 static boolen flag;
public void initialize() {
if (flag)
{// return from here or some message you want to generate 
}else{
    List<Metadata> metadata = getMetadata(true);
    List<Process> process = getProcess();
    if (!metadata.isEmpty() && !process.isEmpty()) {
        Manager.setAllMetadata(metadata, process);
    }
       flag = true;
    startBackgroundThread();       }}

我希望这能解决您的问题

Answer 3

•而且它应该只由一个线程执行。那么如果多个线程在调用下面的方法，那么它应该只被一个线程调用，其他线程应该等待初始化完成？

public static final Object singleThreadLock = new Object();

public void initialize()
{
    synchronized( singleThreadLock )
    {

        List<Metadata> metadata = getMetadata(true);
        List<Process> process = getProcess();
        if (!metadata.isEmpty() && !process.isEmpty()) 
        {
            Manager.setAllMetadata(metadata, process);
        }
       startBackgroundThread();
    } 
  }

这些代码行保证每个线程只调用一次 initialize()，并且由于 singleThreadLock 被声明为静态的，那么你当前生成的 JVM 将永远不会允许任何其他线程访问锁，直到块内同步完全执行。也请远离尝试同步（this），因为这样的语句可能会导致严重的并发问题。