Diretório do artigo
Um esquema de aplicativo de consulta usando "ThreadPoolExecutor + Future" é o seguinte:
// 创建线程池
ExecutorService executor = Executors.newFixedThreadPool(3);
// 异步向电商S1询价
Future<Integer> f1 =
executor.submit(
()->getPriceByS1());
// 异步向电商S2询价
Future<Integer> f2 =
executor.submit(
()->getPriceByS2());
// 异步向电商S3询价
Future<Integer> f3 =
executor.submit(
()->getPriceByS3());
// 获取电商S1报价并异步保存
executor.execute(
()->save(f1.get()));
// 获取电商S2报价并异步保存
executor.execute(
()->save(f2.get())
// 获取电商S3报价并异步保存
executor.execute(
()->save(f3.get())
O problema é : se levar muito tempo para obter a cotação do comércio eletrônico S1, mesmo que a cotação do comércio eletrônico S2 seja muito curta, a operação de salvar a cotação do S2 não poderá ser executada primeiro, porque o encadeamento principal está bloqueado no f1.get () Operação.
Solução : adicione uma fila de bloqueio, obtenha as aspas de S1, S2, S3 na fila de bloqueio e consuma a fila de bloqueio no thread principal, para que as primeiras cotações obtidas sejam salvas no banco de dados.
// 创建阻塞队列
BlockingQueue<Integer> bq = new LinkedBlockingQueue<>();
//电商S1报价异步进入阻塞队列
executor.execute(()->
bq.put(f1.get()));
//电商S2报价异步进入阻塞队列
executor.execute(()->
bq.put(f2.get()));
//电商S3报价异步进入阻塞队列
executor.execute(()->
bq.put(f3.get()));
//异步保存所有报价
for (int i=0; i<3; i++) {
Integer r = bq.take();
executor.execute(()->save(r));
}
1. Use CompletionService para realizar o sistema de consulta
O princípio de implementação do CompletionService também mantém uma fila de bloqueio internamente e adiciona o objeto Futuro do resultado da execução da tarefa à fila de bloqueio.
1.1 Então, como você cria um CompletionService?
A classe de implementação da interface CompletionService é ExecutorCompletionService, dois métodos de construção.
ExecutorCompletionService(Executor executor)；
ExecutorCompletionService(Executor executor, BlockingQueue<Future<V>> completionQueue)
Então, por padrão, usará o LinkedBlockingQueue ilimitado. O objeto Futuro do resultado da execução da tarefa é adicionado ao completQueue.
O código para implementar a consulta é o seguinte:
// 创建线程池
ExecutorService executor = Executors.newFixedThreadPool(3);
// 创建CompletionService
CompletionService<Integer> cs = new ExecutorCompletionService<>(executor);
// 异步向电商S1询价
cs.submit(()->getPriceByS1());
// 异步向电商S2询价
cs.submit(()->getPriceByS2());
// 异步向电商S3询价
cs.submit(()->getPriceByS3());
// 将询价结果异步保存到数据库
for (int i=0; i<3; i++) {
Integer r = cs.take().get();
executor.execute(()->save(r));
}
1.2 Descrição da interface CompletionService
Future<V> submit(Callable<V> task);
// V result传入的结果引用
Future<V> submit(Runnable task, V result);
// 以下三个都跟阻塞队列有关
// 如果队列为空，调用 take() 方法的线程会被阻塞
Future<V> take() throws InterruptedException;
// 如果队列为空，调用 poll() 方法的线程返回null
Future<V> poll();
Future<V> poll(long timeout, TimeUnit unit) throws InterruptedException;
2. Use CompletionService para realizar o Forking Cluster no Dubbo
Dubbo de modelo de cluster bifurcação , apoiar várias consultas em chamadas paralelas do serviço, desde que há um resultado de retorno bem sucedido, todo o serviço pode retornar .
// 创建线程池
ExecutorService executor = Executors.newFixedThreadPool(3);
// 创建CompletionService
CompletionService<Integer> cs = new ExecutorCompletionService<>(executor);
// 用于保存Future对象
List<Future<Integer>> futures = new ArrayList<>(3);
//提交异步任务，并保存future到futures
futures.add(cs.submit(()->geocoderByS1()));
futures.add(cs.submit(()->geocoderByS2()));
futures.add(cs.submit(()->geocoderByS3()));
// 获取最快返回的任务执行结果
Integer r = 0;
try {
// 只要有一个成功返回，则break
for (int i = 0; i < 3; ++i) {
r = cs.take().get();
//简单地通过判空来检查是否成功返回
if (r != null) {
break;
}
}
} finally {
//取消所有任务
for(Future<Integer> f : futures)
f.cancel(true);
}
// 返回结果
return r;
Primeiro, criamos um executor de conjunto de encadeamentos, um objeto CompletionService cs e uma lista de futuros do tipo Futuro. Cada vez que uma tarefa assíncrona é enviada chamando o método CompletionService submit (), um objeto Future é retornado. futuros. Ao chamar cs.take (). Get (), podemos obter o resultado de execução mais rápido da tarefa.Enquanto obtemos um resultado retornado corretamente, podemos cancelar todas as tarefas e retornar o resultado final.
