如果超时间隔到期，Awaitility.await().atMost(...) 会导致程序退出？

Question

这个问题关于 com.jayway.awaitility.Awaitility。

我刚刚尝试了 Awaitility.await()，它似乎有一些奇怪的行为。在下面的测试方法中，如果我注释掉 testWithFuture() 并启用 testWithAwaitility()，我永远不会看到打印出消息“end”。我看到“开始”，然后程序就退出了，似乎永远不会到达第二个打印语句。

因此，作为一种解决方法，我决定使用 Settable{Future} .. 如果其他人有同样的问题，那么我提供的解决方法可能会有用.. 更好的是得到一个很好的答案 ;^) ！提前致谢/克里斯

编码：

import com.google.common.util.concurrent.SettableFuture;

import java.util.Date;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

import static com.jayway.awaitility.Awaitility.await;
import static java.util.concurrent.TimeUnit.SECONDS;

public class AwaitTest {
    static volatile boolean done = false;

    public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
        testWithFuture();
        //testWithAwaitility();
    }

    private static void testWithAwaitility() {
        System.out.println("start " + new Date());
        new Thread(new Runnable(){
            public void run(){
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                done = true;
            }

        }).start();


        await().atMost(2, SECONDS).until(new Callable() {
            @Override
            public Boolean call() throws Exception {
                return done;
            }
        });

        System.out.println("end " + new Date());   // NEVER Reached. i wonder why?

    }

    // This does what I want.
    //
    private static void testWithFuture() throws InterruptedException, ExecutionException, TimeoutException {
        System.out.println("start testWithFuture");

        final SettableFuture future = SettableFuture. create();
        new Thread(new Runnable(){

            public void run(){
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
                }
                future.set("Hello");
            }

        }).start();

        String result = future.get(4, TimeUnit.SECONDS);

        if (! result.equals("Hello")) {
            throw new RuntimeException("not equal");
        } else {
            System.out.println("got Hello");

        }
    }
 }

更正的代码 ->

import java.util.Date;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

import static com.jayway.awaitility.Awaitility.await;
import static java.util.concurrent.TimeUnit.SECONDS;

public class Sample {
    static volatile boolean done = false;

    public static void main(String[] args) {
        testWithAwaitility();
    }

    private static void testWithAwaitility() {
        System.out.println("start " + new Date());
        new Thread(new Runnable(){
            public void run(){
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                done = true;
            }

        }).start();


        try {
            await().atMost(2, SECONDS).until(new Callable() {
                @Override
                public Boolean call() throws Exception {
                    return done;
                }
            });
        } catch (Exception e) {
            System.out.println("FAILED");
            e.printStackTrace();
        }


        System.out.println("end " + new Date());   // REACHED this statement after correction
    }
 }

Answer 1

根据文档，如果达到超时并且条件不为真，则await()抛出 a TimeoutException，因此您的方法此时结束，因为异常通过堆栈向上传播。这解释了这种行为。但是，您应该会看到堆栈跟踪。

如果您想在之后继续执行代码，似乎您需要捕获此异常。