我需要创建一个库，其中包含同步和异步方法。

• executeSynchronous() - 等到我有结果，返回结果。
• executeAsynchronous() - 立即返回一个 Future，如果需要，可以在完成其他事情后对其进行处理。

我的库的核心逻辑

客户将使用我们的库，他们将通过传递 DataKey 构建器对象来调用它。然后，我们将使用该 DataKey 对象构造一个 URL，并通过执行它对该 URL 进行 HTTP 客户端调用，在我们将响应作为 JSON 字符串返回后，我们将该 JSON 字符串发送回我们的客户通过创建 DataResponse 对象。有些客户会调用 executeSynchronous()，有些客户可能会调用 executeAsynchronous()，所以我需要在我的库中分别提供两种方法。

接口(interface):

public interface Client {

    // for synchronous
    public DataResponse executeSynchronous(DataKey key);

    // for asynchronous
    public Future<DataResponse> executeAsynchronous(DataKey key);
}

然后我有我的 DataClient 实现了上面的 Client 接口(interface):

public class DataClient implements Client {

    private RestTemplate restTemplate = new RestTemplate();
    // do I need to have all threads as non-daemon or I can have daemon thread for my use case?
    private ExecutorService executor = Executors.newFixedThreadPool(10);

    // for synchronous call
    @Override
    public DataResponse executeSynchronous(DataKey key) {
        DataResponse dataResponse = null;
        Future<DataResponse> future = null;

        try {
            future = executeAsynchronous(key);
            dataResponse = future.get(key.getTimeout(), TimeUnit.MILLISECONDS);
        } catch (TimeoutException ex) {
            PotoLogging.logErrors(ex, DataErrorEnum.TIMEOUT_ON_CLIENT, key);
            dataResponse = new DataResponse(null, DataErrorEnum.TIMEOUT_ON_CLIENT, DataStatusEnum.ERROR);
            future.cancel(true); // terminating tasks that have timed out
        } catch (Exception ex) {
            PotoLogging.logErrors(ex, DataErrorEnum.CLIENT_ERROR, key);
            dataResponse = new DataResponse(null, DataErrorEnum.CLIENT_ERROR, DataStatusEnum.ERROR);
        }

        return dataResponse;
    }

    //for asynchronous call
    @Override
    public Future<DataResponse> executeAsynchronous(DataKey key) {
        Future<DataResponse> future = null;

        try {
            Task task = new Task(key, restTemplate);
            future = executor.submit(task); 
        } catch (Exception ex) {
            PotoLogging.logErrors(ex, DataErrorEnum.CLIENT_ERROR, key);
        }

        return future;
    }
}

将执行实际任务的简单类:

public class Task implements Callable<DataResponse> {

    private DataKey key;
    private RestTemplate restTemplate;

    public Task(DataKey key, RestTemplate restTemplate) {
        this.key = key;
        this.restTemplate = restTemplate;
    }

    @Override
    public DataResponse call() {
        DataResponse dataResponse = null;
        String response = null;

        try {
            String url = createURL();
            response = restTemplate.getForObject(url, String.class);

            // it is a successful response
            dataResponse = new DataResponse(response, DataErrorEnum.NONE, DataStatusEnum.SUCCESS);
        } catch (RestClientException ex) {
            PotoLogging.logErrors(ex, DataErrorEnum.SERVER_DOWN, key);
            dataResponse = new DataResponse(null, DataErrorEnum.SERVER_DOWN, DataStatusEnum.ERROR);
        } catch (Exception ex) { // should I catch RuntimeException or just Exception here?
            PotoLogging.logErrors(ex, DataErrorEnum.CLIENT_ERROR, key);
            dataResponse = new DataResponse(null, DataErrorEnum.CLIENT_ERROR, DataStatusEnum.ERROR);
        }

        return dataResponse;
    }

    // create a URL by using key object
    private String createURL() {
        String url = somecode;
        return url;
    }
}

我对上述解决方案有几个问题 -

• 对于上述用例，我应该使用守护线程还是非守护线程？
• 此外，我正在终止已超时的任务，这样它就不会长时间占用我有限的 10 个线程中的一个。我这样做看起来对吗？
• 在我的 call() 方法中，我正在捕获异常。我应该在那里捕获 RuntimeException 吗？如果我捕获异常或运行时异常有什么区别？

当我开始研究这个解决方案时，我并没有终止已经超时的任务。我正在向客户端报告超时，但任务仍在线程池中继续运行(可能会长时间占用我有限的 10 个线程中的一个)。所以我在网上做了一些研究，我发现我可以通过使用 cancel on future 来取消那些已经超时的任务，如下所示 -

future.cancel(true);

但我想确定一下，我在 executeSynchronous 方法中取消超时任务的方式是否正确？

因为我在 Future 上调用 cancel() 如果任务仍在队列中，它将停止运行，所以我不确定我在做什么对不对？执行此操作的正确方法是什么？

如果有更好的方法，那么任何人都可以提供一个例子吗？

我们是否应该始终终止已超时的任务？如果我们不这样做，那么我会产生什么影响？

最佳答案

Should I use daemon or non daemon threads for my above use case?

这取决于您是否希望这些线程阻止程序退出。当最后一个非守护线程完成时，JVM 将退出。

如果 JVM 存在，这些任务可以随时终止，那么它们应该是守护进程。如果您希望 JVM 等待它们，则让它们成为非守护进程。

参见:java daemon thread and non-daemon thread

Also, I am terminating the tasks that have timed out so that it doesn't occupy one of my limited 10 threads for a long time. Does that look right the way I am doing it?

是也不是。您正确地调用了 Future 上的 cancel()，如果它仍在队列中，它将停止运行。但是，如果线程已经在运行任务，则取消只会中断线程。 restTemplate 调用可能是不可中断的，因此中断将被忽略。只有某些方法(如 Thread.sleep(...) 是可中断的并抛出 InterruptException。因此调用 future.cancel(true) 不会t 停止操作并终止线程。

参见:Thread not interrupting

你可以做的一件事是在你的 Task 对象上放置一个 cancel() 方法，它强制关闭 restTemplate。您将需要对此进行试验。另一个想法是在 restTemplate 连接或 IO 上设置某种超时，这样它就不会永远等待。

如果您使用的是 Spring RestTemplate，则不会直接关闭，但您可以关闭底层连接，我相信这可能是通过 SimpleClientHttpRequestFactory 进行的，因此您将需要在底层 HttpURLConnection 上调用 disconnect()。

In my call() method, I am catching Exception. Should I catch RuntimeException there?

RuntimeException 扩展了 Exception，因此您已经可以捕获它们。

What is the difference if I catch Exception or RuntimeException?

捕获Exception 捕获已检查(非运行时)异常和 运行时异常。仅捕获 RuntimeException 意味着任何已定义的异常都不会被捕获，并且会被该方法抛出。

RuntimeException 是不需要代码检查的特殊异常。例如，任何代码都可以抛出 IllegalArgumentException 而无需将方法定义为 throws IllegalArgumentException。对于已检查的异常，如果调用方方法未捕获或抛出已检查的异常，则这是一个编译器错误，但对于 RuntimeExceptions 则不是这样。

关于这个主题，这是一个很好的答案:

• Java: checked vs unchecked exception explanation

关于java - 如何在多线程环境下更好的使用ExecutorService？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/29064245/