Differenza tra Futures.addCallBack() e Futures.transform() in Google Guava Concorrenza

Question

Qual è la differenza tra Futures.addCallBack() e Futures.transform() in Google Guava Concurrency.

Come per la documentazione:

Futures.addCallBack():
addCallback(ListenableFuture<V> future, FutureCallback<? super V> callback) registri separati successo e fallimento callback da eseguire quando il calcolo del futuro è completa o, se il calcolo è già completo, immediatamente.

Futures.transform():
transform(ListenableFuture<I> input, AsyncFunction<? super I,? extends O> function) Restituisce un nuovo ListenableFuture il cui risultato è asincrono derivato dal risultato del futuro dato.

Come da mia conoscenza, addCallback() registrerà la chiamata riuscita o l'errore quando l'elaborazione asincrona è completata. In questo caso possiamo gestire l'out put in base a condizioni di successo o di fallimento (esempio: logging, controllo di flusso, ecc.). e transform() restituiscono solo l'oggetto asincrono. Quindi la differenza è solo Callback ?.

1. se la mia comprensione è corretta?
2. Qual è il migliore da utilizzare con l'elaborazione asincrona?
3. Se è necessario chiamare più metodi asincroni in una sequenza, esiste una procedura consigliata?
4. Qual è la differenza tra l'utilizzo di AsyncFunction e Function in transform(ListenableFuture<I> input, Function/AsyncFunction <? super I,? extends O> function)? (AsyncFunction utilizzato solo per annidato Futures.transform()?)

Quello che ho cercato:
cerco di scrivere codice come qui di seguito, se questa è una buona pratica o no.

public ListenableFuture<MyObject> doSomething() { 
    logger.info("Entered in dosomething() Method."); 

    ListeningExecutorService executor = 
      MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(50)); 

    ListenableFuture<MyObject> myAsyncObject = 
      calculator.calculateSomething(input); 
    //internally calculator.calculateSomething() have multiple asynchronous 
    // calls and I am using Futures.transform(), without callback. 

    Futures.addCallback(myAsyncObject, new FutureCallback<MyObject>() { 
     public void onSuccess(MyObject result) { 
      logger.info("Calculation Completed successfully."); 
      //TODO: check for success and log it. 
     } 

     public void onFailure(Throwable thrown) { 
      logErrorDetails(thrown); 
     } 
    }, executor); 

    executor.shutdown(); 

    return myAsyncObject; 
} 

Answer 1

Beh non hai scritto la firma completa metodo nella domanda

• addCallback restituisce nulla
• transform restituisce un futuro che tiene risultato della funzione (se l'ingresso è riuscito) o il errore di input originale (se non). Ciò consente di concatenare le trasformazioni, con un costruttore come la sintassi.

non ho usato AsyncFunction, ma capisco che aggiungono un livello di asincronia, vale a dire il risultato della Future è un altro Future.