延迟异步返回 - IllegalMonitorStateException

Question

我正在尝试在新线程中调用方法，该方法将在使用 callable 延迟后返回一些东西。由于 IllegalMonitorStateException 而下降 当我只创建类的实例，调用方法并且该方法将延迟返回对象时，是否可以以这种方式封装线程服务？ 提前谢谢你。

// ENTITY
public class Result {
    public String name;
    public int value;

    public Result(String name, int value) {
        this.name = name;
        this.value = value;
    }

    public Result() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "Result{" +
                "name='" + name + '\'' +
                ", value=" + value +
                '}';
    }
}

创建带有延迟和返回值的线程

import java.util.concurrent.*;

public class AsyncCallable {

    public Result calculate() throws ExecutionException, InterruptedException {

        int delay = 5000;
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        Callable<Result> callable = () -> {
            this.wait(delay);
            return new Result("Name", 4);
        };

        Future<Result> future = executorService.submit(callable);
        executorService.shutdown();
        return future.get();
    }

}

调用方法：

import java.util.concurrent.ExecutionException;

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        AsyncCallable asyncCallable = new AsyncCallable();

        System.out.println(asyncCallable.calculate().toString());


    }
}

Answer 1

因为您的ExecutorService 只使用一个线程，所以只调用Thread#sleep 而不是Object#wait 应该没问题：

Callable<Result> callable = () -> {
    Thread.sleep(5_000);
    return new Result("Name", 4);
};

Answer 2

好吧，要坚持你的情况，对 wait() 的任何调用都必须包含在同步块中（参见方法 javadoc here）。但是，我认为您应该考虑使用内置工具，例如Scheduled thread pool。使用它，您可以执行以下操作：

import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.Executors;

final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(4);
// Execute a task after 5 seconds
scheduler.schedule(() -> new Result("Name", 4), 5, TimeUnit.SECONDS);