java - Java:WAITING boolean 值变为真实

Question

我实现了一个任务，当前线程将等到之前的工作完成。

代码:

    while (!taskContext.isPreviousWorkDone()) {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            LOGGER.error("Wait failed", e);
        }
    }
    doSomething();

另一个线程将 isPreviousWorkDone设置为true，然后我们可以运行 doSomething()。但是我认为我的代码很糟糕:

我们检查每个100ms，它可能会花费一些CPU资源。

很难添加等待超时。 (如果isPreviousWorkDone从不变为真怎么办？)

那么，如何正确执行这样的等待呢？

Answer 1

请改用 CountDownLatch 。 java.util.concurrent.CountDownLatch允许一个或多个线程等待某些操作完成。

使用给定的计数初始化CountDownLatch。需要等待某种条件/操作(计数达到零)的线程，调用await()方法之一。通过调用countdown()方法，计数从完成某些操作的线程中递减。然后，所有等待线程继续执行。

示例

// create latch with count of one (1)
CountDownLatch latch = new CountDownLatch(1);

// create instances of classes that implement Runnable
Waiter waiter = new Waiter(latch);
Worker worker = new Worker(latch);

// start threads
new Thread(waiter).start();
new Thread(worker).start();

定义Waiter Runnable(等待某些操作完成)

public class Waiter implements Runnable{
    CountDownLatch latch = null;

    public Waiter(CountDownLatch latch) {
        this.latch = latch;
    }

    public void run() {
        try {
            // wait for the latch to be released
            latch.await();
        } catch (InterruptedException e) {
            // set interupt flag
            Thread.currentThread().interrupt();
            // log interrupt
            System.out.println("Interrupted");
        }
        System.out.println("Unblocked");

        doSomething();
    }
}

定义Worker Runnable(执行一些操作)

public class Worker implements Runnable {
    CountDownLatch latch = null;

    public Worker(CountDownLatch latch) {
        this.latch = latch;
    }

    public void run() {
        // do some job

        // when ready release latch
        latch.countDown();

        System.out.println("Latch Released");
    }
}

避免

使用旧的等待通知Java API。原因是 虚假唤醒。那是您的线程在没有得到实际通知的情况下被唤醒，因此您必须检查条件是否得到满足，否则将继续等待。

来自javadocs 的虚假唤醒

线程也可以唤醒，而不会被通知，中断或超时，即所谓的虚假唤醒。尽管在实践中这种情况很少发生，但是应用程序必须通过测试应该导致线程唤醒的条件来防范它，并在条件不满足时继续等待。换句话说，等待应该总是在循环中发生，就像这样:

 synchronized (obj) {
     while (<condition does not hold>)
         obj.wait(timeout);
     ... // Perform action appropriate to condition
 }

(有关此主题的更多信息，请参见Doug Lea的“Java并行编程(第二版)”(Addison-Wesley，2000年)中的3.2.3节，或Joshua Bloch的“有效Java编程语言指南”(Addison-卫斯理(Wesley)，2001年)。