Futuretask不管用

Question

我以类似于Brian的“FutureTask Java并发在实践中的应用”(代码示例可以找到这里，清单5.12)的方式创建了一个5.12。

问题是，即使给出10秒的时间，任务也会超时。任务只返回true，因此不应该有发生的原因：

public static void main(String[] args) throws Exception {

    FutureTask<Boolean> task = new FutureTask<>(new Callable<Boolean>() {
        @Override
        public Boolean call() throws Exception {
            return true;
        }
    });

    System.out.println(task.get(10, TimeUnit.SECONDS));
}

此代码打印：

Exception in thread "main" java.util.concurrent.TimeoutException
    at java.util.concurrent.FutureTask.get(Unknown Source)
    at Main.main(Main.java:19)

Answer 1

你还没完成任务。永远也不会有结果。javadoc态

该类提供了Future、的基本实现，并提供了启动和取消(计算)、查询以查看计算是否完成以及检索计算的结果的方法。只有在计算完成时才能检索结果

将任务提交给要异步运行的ExecutorService。

Executors.newSingleThreadExecutor().submit(task); // ideally shutdown the ExecutorService afterwards

或者同步运行它。

task.run();

在您提供的链接中，我假设在尝试获得结果之前调用了在新的start()中运行FutureTask的FutureTask方法。

Answer 2

当您应用代码task.get(10, TimeUnit.SECONDS);时，FutureTask的状态将永远不会更改，最后将抛出TimeoutException。

您可以在java.util.concurrent.FutureTask的源代码中看到这一点(参见openjdk源代码http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/concurrent/FutureTask.java#FutureTask.get%28%29)：

public V get(long timeout, TimeUnit unit)
    throws InterruptedException, ExecutionException, TimeoutException {
    return sync.innerGet(unit.toNanos(timeout));
}

// In inner class java.util.concurrent.FutureTask.Sync (extends java.util.concurrent.locks.AbstractQueuedSynchronize)
// and in java.util.concurrent.locks.AbstractQueuedSynchronize:
innerGet(long nanosTimeout) throws InterruptedException, ExecutionException, TimeoutException {
    if (!tryAcquireSharedNanos(0, nanosTimeout))
        throw new TimeoutException();
    if (getState() == CANCELLED)
        throw new CancellationException();
    if (exception != null)
        throw new ExecutionException(exception);

    return result;
}

public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout) throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    return tryAcquireShared(arg) >= 0 ||
        doAcquireSharedNanos(arg, nanosTimeout);
}

protected int tryAcquireShared(int ignore) {
    return innerIsDone() ? 1 : -1;
}

boolean innerIsDone() {
    return ranOrCancelled(getState()) && runner == null;
}

private boolean ranOrCancelled(int state) {
    return (state & (RAN | CANCELLED)) != 0;
}
// I know it's difficult :|
private void doAcquireShared(int arg) {
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();
            if (p == head) {
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    if (interrupted) selfInterrupt();
                    failed = false;
                    return;
                }
            }
            if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed) cancelAcquire(node);
    }
}

对不起我的英语。