Continua quando si prevede un risultato futuro

Question

Ho 3 oggetti FutureTask<T>. Voglio che vengano elaborati in modo asincrono. Tuttavia, non appena uno dei metodi get() di FutureTasks non restituisce null, desidero continuare i.e il mio metodo (wrapper) restituisce e non attende finché non vengono elaborati gli altri due FutureTasks. ho pensato a qualcosa di simile:

private File wrapper(final File file) { 
    ExecutorService executors = Executors.newCachedThreadPool(); 
    File returnFile; 
    FutureTask<File> normal= ... 
    FutureTask<File> medium=...  
    FutureTask<File> huge=... 

    executors.execute(normal); 
    executors.execute(medium); 
    executors.execute(huge); 
    try { 
     if((returnFile=normal.get()) != null || 
      (returnFile=medium.get()) != null || 
      (returnFile=huge.get()) != null) 

      return returnFile; 

    } catch(ExecutionException | InterruptedException e) { } 
} 

Non sono sicuro di come catturare le eccezioni (generata dalla get()) in modo corretto, perché presumo che saranno gettati da quando ho appena ritorno senza aspettare gli altri due compiti da completare. Inoltre ho dubbi sul fatto che il codice funzioni come previsto. Sento che sono vicino alla soluzione ma mi manca qualcosa.

Answer 1

Posso suggerire di verificare FutureTask :: isDone?

sarebbe qualcosa come questo allora:

while(true) { 
    if (normal.isDone()) { 
     return normal.get(); 
    } 
    if (medium.isDone()) { 
     return medium.get(); 
    } 
    if (huge.isDone()) { 
     return huge.get(); 
    } 
} 

EDIT: Si potrebbe cancel gli altri compiti, non appena si dispone di uno dei risultati a portata di mano.

Utilizzando FutureTask::get non è ciò che cercate in quanto sarebbe molto probabilmente tornare sempre il risultato di normal.get() in quanto la documentazione afferma già che:

Waits, se necessario, per il calcolo per completare, e quindi recupera il suo risultato.

Per chiarire quanto sopra: Se si utilizza FutureTask :: ottenere il primo FutureTask si chiama ottenere su molto probabilmente blocco ed attendere fino a quando il risultato è disponibile a tornare.

EDIT2:

Wrap quel ciclo in una nuova Runnable, eseguito dal ExecutorService, passando il primo risultato a disposizione un altro metodo o implementare una richiamata e non c'è più occupato attesa.

Answer 2

Ho avuto un'idea di progettarlo utilizzando BlockingQueue. Estendi le tue attività con il metodo done che invia i risultati in BlockinQueue e, una volta che il client ha ricevuto il primo risultato, annulla altre attività. D'altra parte, experts suggest using ExecutorCompletionService invece. Sembra serializzare i risultati imself e has all appropriate examples.