भविष्य <Future<T>> भविष्य में <T> में बदलने का कोई आसान तरीका है?

Question

मेरे पास कुछ कोड है जो किसी अन्य थ्रेड के लिए अनुरोध सबमिट करता है जो उस अनुरोध को अभी तक एक और थ्रेड सबमिट नहीं कर सकता है या नहीं। इससे Future<Future<T>> का रिटर्न प्रकार मिलता है। क्या यह Future<T> में तुरंत चालू करने के लिए कुछ गैर-जघन्य तरीका है जो पूरी भविष्य श्रृंखला के पूरा होने की प्रतीक्षा करता है?

मैं पहले से ही अन्य मज़ेदार समवर्ती सामानों को संभालने और Google संग्रह के प्रतिस्थापन के रूप में और इसके कामकाजी के रूप में अच्छी तरह से काम करने के लिए गुवा पुस्तकालय का उपयोग कर रहा हूं लेकिन मुझे इस मामले के लिए कुछ नहीं मिल रहा है।)

public class UnwrapFuture<T> implements Future<T> { 
    Future<Future<T>> wrappedFuture; 

    public UnwrapFuture(Future<Future<T>> wrappedFuture) { 
     this.wrappedFuture = wrappedFuture; 
    } 

    public boolean cancel(boolean mayInterruptIfRunning) { 
     try { 
      return wrappedFuture.get().cancel(mayInterruptIfRunning); 
     } catch (InterruptedException e) { 
      //todo: do something 
     } catch (ExecutionException e) { 
      //todo: do something 
     } 
    } 
    ... 
} 

आप अपवादों कि मिल (से निपटने के लिए होगा बढ़ा सकते हैं लेकिन अन्य तरीकों नहीं कर सकते हैं:

Answer 1

गुवा 13.0 Futures.dereference इसे करने के लिए जोड़ता है। इसे सादे Future<Future> के बजाय ListenableFuture<ListenableFuture> की आवश्यकता है। (एक सादे Future पर संचालन करने के लिए एक मेकलिस्टेबल कॉल की आवश्यकता होगी, जिनमें से प्रत्येक को कार्य के जीवनकाल के लिए एक समर्पित धागा की आवश्यकता होती है (जैसा कि विधि के नए नाम, JdkFutureAdapters.listenInPoolThread द्वारा स्पष्ट किया गया है)।

Answer 2

आप एक वर्ग की तरह बना सकते हैं।

Answer 3

यह मेरा पहला पड़ाव था लेकिन मुझे यकीन है कि इसमें बहुत गड़बड़ है। Futures.compress(f) जैसे कुछ के साथ इसे बदलने के लिए मुझे खुशी होगी।

public class CompressedFuture<T> implements Future<T> { 
    private final Future<Future<T>> delegate; 

    public CompressedFuture(Future<Future<T>> delegate) { 
     this.delegate = delegate; 
    } 

    @Override 
    public boolean cancel(boolean mayInterruptIfRunning) { 
     if (delegate.isDone()) { 
      return delegate.cancel(mayInterruptIfRunning); 
     } 
     try { 
      return delegate.get().cancel(mayInterruptIfRunning); 
     } catch (InterruptedException e) { 
      throw new RuntimeException("Error fetching a finished future", e); 
     } catch (ExecutionException e) { 
      throw new RuntimeException("Error fetching a finished future", e); 
     } 
    } 

    @Override 
    public T get() throws InterruptedException, ExecutionException { 
     return delegate.get().get(); 
    } 

    @Override 
    public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { 
     long endTime = System.currentTimeMillis() + unit.toMillis(timeout); 
     Future<T> next = delegate.get(timeout, unit); 
     return next.get(endTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS); 
    } 

    @Override 
    public boolean isCancelled() { 
     if (!delegate.isDone()) { 
      return delegate.isCancelled(); 
     } 
     try { 
      return delegate.get().isCancelled(); 
     } catch (InterruptedException e) { 
      throw new RuntimeException("Error fetching a finished future", e); 
     } catch (ExecutionException e) { 
      throw new RuntimeException("Error fetching a finished future", e); 
     } 
    } 

    @Override 
    public boolean isDone() { 
     if (!delegate.isDone()) { 
      return false; 
     } 
     try { 
      return delegate.get().isDone(); 
     } catch (InterruptedException e) { 
      throw new RuntimeException("Error fetching a finished future", e); 
     } catch (ExecutionException e) { 
      throw new RuntimeException("Error fetching a finished future", e); 
     } 
    } 
} 

Answer 4

मुझे लगता है कि भविष्य के अनुबंध को लागू करने के लिए यह सबसे अच्छा किया जा सकता है। मैंने जितना संभव हो उतना चालाक होने का प्रयास किया ताकि यह सुनिश्चित किया जा सके कि यह अनुबंध को पूरा करता है। विशेष रूप से टाइमआउट के साथ प्राप्त करने के कार्यान्वयन नहीं।

import java.util.concurrent.*; 

public class Futures { 
    public <T> Future<T> flatten(Future<Future<T>> future) { 
    return new FlattenedFuture<T>(future); 
    } 

    private static class FlattenedFuture<T> implements Future<T> { 
    private final Future<Future<T>> future; 

    public FlattenedFuture(Future<Future<T>> future) { 
     this.future = future; 
    } 

    public boolean cancel(boolean mayInterruptIfRunning) { 
     if (!future.isDone()) { 
     return future.cancel(mayInterruptIfRunning); 
     } else { 
     while (true) { 
      try { 
      return future.get().cancel(mayInterruptIfRunning); 
      } catch (CancellationException ce) { 
      return true; 
      } catch (ExecutionException ee) { 
      return false; 
      } catch (InterruptedException ie) { 
      // pass 
      } 
     } 
     } 
    } 

    public T get() throws InterruptedException, 
          CancellationException, 
          ExecutionException 
    { 
     return future.get().get(); 
    } 

    public T get(long timeout, TimeUnit unit) throws InterruptedException, 
                CancellationException, 
                ExecutionException, 
                TimeoutException 
    { 
     if (future.isDone()) { 
     return future.get().get(timeout, unit); 
     } else { 
     return future.get(timeout, unit).get(0, TimeUnit.SECONDS); 
     } 
    } 

    public boolean isCancelled() { 
     while (true) { 
     try { 
      return future.isCancelled() || future.get().isCancelled(); 
     } catch (CancellationException ce) { 
      return true; 
     } catch (ExecutionException ee) { 
      return false; 
     } catch (InterruptedException ie) { 
      // pass 
     } 
     } 
    } 

    public boolean isDone() { 
     return future.isDone() && innerIsDone(); 
    } 

    private boolean innerIsDone() { 
     while (true) { 
     try { 
      return future.get().isDone(); 
     } catch (CancellationException ce) { 
      return true; 
     } catch (ExecutionException ee) { 
      return true; 
     } catch (InterruptedException ie) { 
      // pass 
     } 
     } 
    } 
    } 
} 

Answer 5

अमरूद पुस्तकालयों का उपयोग करने वाला एक और संभावित कार्यान्वयन और बहुत आसान है।

import java.util.concurrent.*; 
import com.google.common.util.concurrent.*; 
import com.google.common.base.*; 

public class FFutures { 
    public <T> Future<T> flatten(Future<Future<T>> future) { 
    return Futures.chain(Futures.makeListenable(future), new Function<Future<T>, ListenableFuture<T>>() { 
     public ListenableFuture<T> apply(Future<T> f) { 
     return Futures.makeListenable(f); 
     } 
    }); 
    } 
}