Concurrencia es un problema, pero puede ser a través del uso de simple y poderosa resumen simplificado de manera significativa, con el fin de simplificar el problema, guayaba amplía las interfaces de futuros que ListenableFuture (puede escuchar el futuro).
Recomiendo encarecidamente que utilice toda su ListenableFuture código para reemplazar el futuro, por las siguientes razones:
- clase de muchas maneras Futuros requiere. (futuros herramientas para el uso)
- Es más fácil que ListenableFutrue transformación posterior. (Fácil de usar que la reconstrucción anterior)
- Proporciona herramientas necesarias para proporcionar un método y futuros métodos variante ListenableFuture. (No necesita dos juegos compatibles)
interfaz
A futrue asíncrono convencional representa un resultado del cálculo: una terminación puede o no puede completar el cálculo de la salida.
El progreso futuro puede ser usado en un cálculo, o es el resultado de nuestro compromiso con la prestación de servicios.
ListenableFuture permitido registrar una devolución de llamada cuando haya terminado en el cálculo o cálculo se ha completado.
Este sencillo mejoras hacen posible soportar de manera eficiente operativo múltiple. Las interfaces futuras no son compatibles.
ListenbleFuture funcionamiento básico es añadido
addListener (Ejecutable, Ejecutor),
lo que indica cuando el siguiente cálculo es completa, la carrera Ejecutable se especifica en el Ejecutor especificado.
aumento de devolución de llamada
Muchos usuarios prefieren utilizar Futures.addCallback método (ListenableFuture, FutureCallback, Ejecutor).
FutureCallback logra los dos métodos siguientes:
- onSuccess (v) cuando la aplicación con éxito de la acción futura, basado en los resultados de los cálculos
- onFailure (Throwable) Cuando la acción no cumple con el futuro, basada en la falta
crear
En comparación con ExecutorService.submit (Callable) proporciona un método para inicializar un cálculo asíncrono JDK. Devuelve un futuro regular,
la guayaba proporciona una interfaz ListeningExecutorService que los rendimientos ListenableFuture.
ExecutorService a ListenableExecutorService convertido
uso: MoreExecutors.listeningDecorator (ExecutorService)
El uso básico es el siguiente:
/**
* 说明：使用例子代码
* @author carter
* 创建时间： 2020年03月19日 9:54 上午
**/
@Slf4j
public class ListenableFutureUtils {
public static void main(String[] args) {
ListeningExecutorService service = MoreExecutors.listeningDecorator(
Executors.newFixedThreadPool(10));
final ListenableFuture<AResult> listenableFuture = service.submit(() -> {
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
return new AResult(30, "male", 1);
});
Futures.addCallback(listenableFuture,
new FutureCallback<AResult>() {
@Override
public void onSuccess(AResult aResult) {
log.info("计算成功，{}",aResult);
}
@Override
public void onFailure(Throwable throwable) {
log.error("计算错误",throwable);
}
},service);
}
@Data
@AllArgsConstructor
public static class AResult{
private Integer age;
private String sex;
private Integer id;
}
}复制代码Por el contrario, si desea convertir de la FutureTask basada en API más,
la guayaba ofertas
ListenableFutureTask.create (Exigible)
y
ListenableFutureTask.create (Ejecutable)
es diferente del JDK, ListenableFutureTask que no se concede directamente.
Si te gusta valor abstracto conjunto futuro, en lugar de aplicar un método y valores calculados, considere el uso o uso AbstractFuture SettableFuture;
Si usted necesita para convertir futuro ListenableFuture, no tiene otra opción, debe utilizar JdkFutureAdapters.listenInPoolThread (futuro) para convertir el futuro es ListenableFuture
Siempre que sea posible, se recomienda que modifique el código fuente para devolver un ListenableFuture
solicitud
La razón de usar ListenablFuture Lo más importante es usar una cadena de operaciones asincrónicas.
Código es el siguiente:
package com.xxx.demo;
import com.google.common.util.concurrent.AsyncFunction;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import lombok.AllArgsConstructor;
import lombok.Data;
/**
* 说明：异步操作链
* @author carter
* 创建时间： 2020年03月19日 10:11 上午
**/
public class ApplicationUtils {
public static void main(String[] args) {
Query query = new Query(30);
ListenableFuture<RowKey> rowKeyFuture = lookUp(query);
AsyncFunction<RowKey, QueryResult> queryFun = rowKey -> readData(rowKey);
final ListenableFuture<QueryResult> queryResultListenableFuture =
Futures.transformAsync(rowKeyFuture, queryFun);
}
private static ListenableFuture<QueryResult> readData(RowKey rowKey) {
return null;
}
private static ListenableFuture<RowKey> lookUp(Query query) {
return null;
}
@Data
@AllArgsConstructor
public static class RowKey {
private String id;
}
@Data
@AllArgsConstructor
public static class Query {
private Integer age;
}
@Data
@AllArgsConstructor
public static class QueryResult {
private String id;
private String age;
}
}
复制代码Muchos otros ListenableFuture operativo compatible, proporcionan una eficiente, al tiempo futuro no se proporciona.
Las diferentes operaciones se pueden realizar en un diferentes grupos de subprocesos, un simple ListenableFuture puede tener múltiples operaciones de espera.
Mientras que comenzó la operación, una serie de otras operaciones debe comenzar, ventilador de salida, un millar de velas competir.
ListenableFuture puede lograr tal operación: se desencadena una devolución de llamada para todas las solicitudes.
Una obra poco, podemos fan-in.
ListenableFuture un disparador para obtener los resultados, cuando el otro extremo del Futuro.
Futures.allAsList es un caso en punto.
Métodos Introducción:
| método | descripción |
|---|---|
| transformAsync (ListenableFuture, AsyncFunction, ejecutor) | Devuelve un nuevo ListenableFuture, el resultado es una función asíncrona de retorno, la función devuelve el parámetro resultado es ListenableFuture; |
| transformar (ListenableFuture, función, Ejecutor) | Devuelve un nuevo ListenableFuture, devuelve un resultado de la ejecución de la función, la función devuelve el parámetro resultado es ListenableFuture; |
| allAsList (Iterable
|
Devuelve un ListenableFuture, su resultado es una lista, que contiene los resultados de ejecución ListenableFuture de cada lista, un ListenableFuture cualquier incumplimiento o cancelar, cancelar el resultado de la declaración final |
| successfullAsList (Iterable
|
Devuelve un ListenableFuture, su resultado es una lista, que contiene los resultados de ejecución ListenableFuture de cada lista, el éxito es el resultado de, o la falta de cancelar el valor del uso de null alternativo |
AsyncFunction <A, B> proporciona un método, ListenableFuture Aplicar (A inpunt), que puede ser utilizado para convertir el valor de la desincronización.
Código es el siguiente:
package com.xxx.demo;
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import java.util.List;
/**
* 说明：成功执行结果汇集
* @author carter
* 创建时间： 2020年03月19日 10:34 上午
**/
@Slf4j
public class Test3 {
public static void main(String[] args) {
List<ListenableFuture<QueryResult>> querys = Lists.newLinkedList();
final ListenableFuture<List<QueryResult>> successfulAsList =
Futures.successfulAsList(querys);
Futures.addCallback(successfulAsList, new FutureCallback<List<QueryResult>>() {
@Override
public void onSuccess(List<QueryResult> queryResults) {
log.info("执行结果列表：{}",queryResults);
}
@Override
public void onFailure(Throwable throwable) {
log.error("执行失败",throwable);
}
});
}
@Data
@AllArgsConstructor
public static class QueryResult{
private Integer age;
}
}
复制代码anidada futuro
Su código llama a una interfaz común y devuelve un futuro, es probable que finalmente devuelve un futuro anidada.
package com.xxx.demo;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
import lombok.AllArgsConstructor;
import lombok.Data;
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
/**
* 说明：嵌套的ListenableFuture
* @author carter
* 创建时间： 2020年03月19日 10:43 上午
**/
public class Test4 {
public static void main(String[] args) {
final ListeningExecutorService executorService = MoreExecutors
.listeningDecorator(Executors.newFixedThreadPool(2));
final ListeningExecutorService otherExecutorService = MoreExecutors
.listeningDecorator(Executors.newFixedThreadPool(2));
Callable<Foo> otherCallback = ()->new Foo("aaa");
final ListenableFuture<ListenableFuture<Foo>> submit =
executorService.submit(() -> otherExecutorService.submit(otherCallback));
}
@Data
@AllArgsConstructor
public static class Foo{
private String name;
}
}
复制代码Ejemplos de las últimas vueltas: ListenableFuture <ListenableFuture
Este código es incorrecto, ya que cuando la capa externa del Futuro cancelada, no se pasan a la capa interna del Futuro,
que es también un acostumbrarse () inspección de rutina o de otro futuro del error Listnener,
Sin embargo, será suprimida a menos atención arrojado excepción especial de lo contrario otherCallback.
Para evitar esta situación, el tratamiento futuro de todos los de la guayaba (algunos de JDK), allí * versión asíncrona para desbloquear la seguridad del nido.
比如: Transformar, transformAsyn, enviar, submitAsync 方法.
Estudio en profundidad
El original no es fácil, por favor indique la fuente.