具有延迟的异步 return - IllegalMonitorStateException

Question

我正在尝试在新线程中调用方法，该方法将 return 使用可调用延迟后的内容。由于 IllegalMonitorStateException 而下降是否有可能以这种方式封装线程服务，当我只创建 class 的实例时，调用方法并且该方法将延迟 return 对象？提前谢谢你。

// 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 +
                '}';
    }
}

创建具有延迟和 return 值的线程

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). But, I think you should consider using built-in tools, like 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);

具有延迟的异步 return - IllegalMonitorStateException

Async return with delay - IllegalMonitorStateException

java

multithreading

asynchronous

callable