等待 x 秒或直到条件变为真

Question

如何等待 x 秒或直到条件变为真？等待时应定期测试该条件。目前我正在使用此代码，但应该有一个简短的功能。

for (int i = 10; i > 0 && !condition(); i--) {
    Thread.sleep(1000);
}

Answer 1

假设您想要您所要求的，而不是重新设计代码的建议，您应该查看Awaitility。

例如，如果您想查看是否会在接下来的 10 秒内创建文件，您可以执行以下操作：

await().atMost(10, SECONDS).until(() -> myFile.exists());

它主要用于测试，但执行特定请求的技巧，即等待调用者指定的任意条件，而无需显式同步或睡眠调用。如果您不想使用该库，只需阅读代码以了解它的工作方式。

在这种情况下，这归结为与问题类似的轮询循环，但将 Java 8 lambda 作为参数传入，而不是内联条件。

Answer 2

我没有在 JDK 中找到解决方案。我觉得这个功能应该加到JDK里面去。

这是我使用功能接口实现的：

import java.util.concurrent.TimeoutException;
import java.util.function.BooleanSupplier;

public interface WaitUntilUtils {

  static void waitUntil(BooleanSupplier condition, long timeoutms) throws TimeoutException{
    long start = System.currentTimeMillis();
    while (!condition.getAsBoolean()){
      if (System.currentTimeMillis() - start > timeoutms ){
        throw new TimeoutException(String.format("Condition not met within %s ms",timeoutms));
      }
    }
  }
}

Answer 3

您是否考虑过 java.util.concurrent 中的一些类 - 例如 BlockingQueue？ 你可以使用：

BlockingQueue<Boolean> conditionMet = new BlockingQueue<Boolean>;
conditionMet.poll(10,TimeUnit.SECONDS);

然后在更改条件的代码中执行以下操作：

conditionMet.put(true);

编辑：

另一个例子 java.util.concurrent 可能是 CountDownLatch:

CountDownLatch siteWasRenderedLatch = new CountDownLatch(1);
boolean siteWasRendered = siteWasRenderedLatch.await(10,TimeUnit.SECONDS);

这样您将等待 10 秒或直到闩锁达到零。要达到零，您只需：

siteWasRenderedLatch.countDown();

这样您就不需要使用@Adrian 提供的条件示例中需要的锁。我认为这更简单直接。

如果您不喜欢命名“Latch”或“Queue”，您可以随时将其包装到您自己的名为 LimitedTimeCondition 的类中：

public class LimitedTimeCondition
{
    private CountDownLatch conditionMetLatch;
    private Integer unitsCount;
    private TimeUnit unit;

    public LimitedTimeCondition(final Integer unitsCount, final TimeUnit unit)
    {
        conditionMetLatch = new CountDownLatch(1);
        this.unitsCount = unitsCount;
        this.unit = unit;
    }

    public boolean waitForConditionToBeMet()
    {
        try
        {
            return conditionMetLatch.await(unitsCount, unit);
        }
        catch (final InterruptedException e)
        {
            System.out.println("Someone has disturbed the condition awaiter.");
            return false;
        }

    }

    public void conditionWasMet()
    {
        conditionMetLatch.countDown();
    }
}

而用法是：

LimitedTimeCondition siteRenderedCondition = new LimitedTimeCondition(10, TimeUnit.SECONDS);
//
...
//
if (siteRenderedCondition.waitForConditionToBeMet())
{
   doStuff();
}
else
{
   System.out.println("Site was not rendered properly");
}
//
...
// in condition checker/achiever:
if (siteWasRendered)
{
   condition.conditionWasMet();
}

Answer 4

看看Condition。

条件（也称为条件队列或条件变量） 提供一种方法让一个线程暂停执行（“等待”）直到 由另一个线程通知某些状态条件现在可能为真。 因为对这个共享状态信息的访问发生在不同的 线程，它必须被保护，所以某种形式的锁是相关联的 与条件。等待条件的关键属性 提供的是它以原子方式释放关联的锁，并且 暂停当前​​线程，就像 Object.wait 一样。

条件实例本质上绑定到锁。获得一个 特定 Lock 实例的条件实例使用其 newCondition() 方法。

编辑：

• 相关问题Sleep and check until condition is true
• 相关问题is there a 'block until condition becomes true' function in java?

Answer 5

您可能想要使用类似下面的代码（其中secondsToWait 包含您希望等待的最大秒数，以查看condition() 是否变为真。如果条件为，变量isCondetionMet 将包含真found，如果代码等待条件超时，则返回 false。

        long endWaitTime = System.currentTimeMillis() + secondsToWait*1000;
        boolean isConditionMet = false;
        while (System.currentTimeMillis() < endWaitTime && !isConditionMet) {
            isConditionMet = condition();
            if (isConditionMet) {
                break;
            } else {
                Thread.sleep(1000);
            }
        }

Answer 6

我正在使用原始问题解决方案的以下改编：

public class Satisfied {
    public static boolean inTime(Callable<Boolean> condition, int timeoutInSecs) {
        int count;
        try {
            for (count = 1; count < timeoutInSecs * 20 && !condition.call(); count++)
                Thread.sleep(50);
            return (count < timeoutInSecs * 20);
        } catch (Exception e) {
            throw new AssertionError(e.getMessage());
        }
    }
}

在测试中使用时是这样的：

assertThat(Satisfied.inTime(() -> myCondition(), 5)).isTrue();