在库中实现同步和异步方法的正确方法是什么？

Question

我需要制作一个具有同步和异步功能的库。

executeSynchronous() - 等到我有结果，returns 结果。
executeAsynchronous() - returns 如果需要，可以在其他事情完成后立即处理 Future。

我的库的核心逻辑

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

接口：

public interface Client {

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

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

然后我的 DataClient 实现了上面的 Client 接口：

public class DataClient implements Client {

    private RestTemplate restTemplate = new RestTemplate();
    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);
        } 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;
    }
}

简单 class 将执行实际任务：

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) {
            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;
    }
}

我们公司的客户将通过在他们的代码库中使用我的工厂来使用我的库，如下所示 -

// if they are calling `executeSynchronous()` method
DataResponse response = DataClientFactory.getInstance().executeSynchronous(dataKey);

// and if they want to call `executeAsynchronous()` method
Future<DataResponse> response = DataClientFactory.getInstance().executeAsynchronous(dataKey);

为我的库实现同步和异步方法的最佳方式是什么？实施 sync call as async + waiting 是个坏主意吗？因为在我当前的设置下，每次调用它都会消耗线程池中的一个线程？如果是，那么谁能解释为什么这是个坏主意，它会不会有任何性能问题？

根据上述标准，您将如何实现同步和异步方法？做这个的最好方式是什么？这个库将在非常重的负载下使用，它必须很快，这意味着无论我的服务器正在响应什么，它都应该花费时间。

我应该在异步非阻塞架构的代码库中使用 AsyncRestTemplate 吗？

Answer 1

对于synchronous调用，在单独的线程中执行绝对不是一个好主意。在这种情况下，您会为线程产生额外的成本和资源以及线程上下文切换的成本。

如果有很多 synchronous 调用，那么您将不必要地阻塞 asynchronous 调用的线程，因为您的执行程序是固定大小的线程。那样的话系统的总吞吐量会少一些。

例如：如果有 10 个客户端分别调用 synchronous 和 asynchronous 调用，那么在您的实现中只有线程会实际工作。但是，如果您也使用客户端线程而不是将 synchronous 调用作为 asynchronous 并等待，那么将同时处理所有 20 个调用。

Answer 2

我觉得这样更好：

@Override
public DataResponse executeSynchronous(DataKey key) {
    Task task = new Task(key, restTemplate);
    return task.call();
}

它执行相同的工作，清晰、简短且没有开销。

请注意，他还清除了您当前拥有的重复异常处理。

如果超时是必须，一个选项是使用 RestTemplate class 的基础超时，如 [=13= 中所述]

然后超时将导致您或库客户端可以处理的RestClientException。

Answer 3

我不会为那个任务烦恼 class。只需让您的同步方法完成所有工作并从异步方法异步调用它即可。

public class DataClient implements Client {

    private RestTemplate restTemplate = new RestTemplate();
    private ExecutorService executor = Executors.newFixedThreadPool(10);

    // for synchronous call
    @Override
    public DataResponse executeSynchronous(DataKey key) {
        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) {
            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(final DataKey key) {
        return executor.submit(new Callable<DataResponse>() {
            @Override
            public DataResponse call() throws Exception {
                return executeSynchronous(key);
            }
        });
    }
}

Answer 4

上面通过async执行同步任务的代码等同于把所有的东西都设置为async。如果这是要求，那么我建议您使用 google guava 的 ListenableFuture。我不是拥护者，但它有管理任务超时的方法，编写良好的回调来处理 onSuccess 和 onFailure 场景。 https://code.google.com/p/guava-libraries/wiki/ListenableFutureExplained

Answer 5

如果您在同步操作的情况下（实际上不需要）创建新线程，则会导致性能下降。您基本上是在创建新线程（读作浪费资源），甚至没有从中获得任何好处。话虽如此，我认为更好的方法是将 HTTP 部分包装在不同的 class 中。这样您就可以在同步和异步情况下重新使用 HTTP 访问代码。

class HTTPAccess{
    private RestTemplate restTemplate;
    private DataKey key;

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

    }


    public DataResponse performRequest() {
        DataResponse dataResponse = 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) {
            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;
    }

}

现在对于客户端实现，只需使用此 class。

public class DataClient implements Client {

    private ExecutorService executor = Executors.newFixedThreadPool(10);
    private RestTemplate restTemplate;
    private void initRestClient(DataKey key){
    if(restTemplate == null)
        restTemplate = new RestTemplate(clientHttpRequestFactory(key));
    }

    private ClientHttpRequestFactory clientHttpRequestFactory(DataKey key) {
        HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
        factory.setReadTimeout(key.getTimeout());
        factory.setConnectTimeout(key.getTimeout());
        //if you need to set otherparams this is the place we can do it extracting from DataKey obj
        return factory;
    }

    // for synchronous call
    @Override
    public DataResponse executeSynchronous(DataKey key) {
        initRestClient(key);
        DataResponse dataResponse = new HTTPAccess(key).performRequest();
        return dataResponse;
    }

    //for asynchronous call
    @Override
    public Future<DataResponse> executeAsynchronous(final DataKey key) {
        return executor.submit(new Callable<DataResponse>() {
            @Override
            public DataResponse call() throws Exception {
                return executeSynchronous(key);
            }
        });
    }
}

这样您的 HTTP 实现是完全独立的，如果您将来需要更改接收 DataResponse 的方式（可能来自数据库调用），那么您必须更改 HTTPAccess仅class，其他部分不受影响。

在库中实现同步和异步方法的正确方法是什么？

What is the right way to implement sync and async methods in a library?

java

performance

multithreading

executorservice

resttemplate