isDoneでポーリングを使用し、キャンセルするのではなくJava Futureでキャンセルする

Question

私はリファクタリングできないレガシーコードを作成しています。

このコードでは、Java Futureのブロックを使用しています。これはfuture.get（withTimeOut、...）を使用します。これは、適切なサイズのスレッドプールを十分に応答させる必要があることを意味します。コールが終了するか、タイムアウトするまでブロックされます。

質問： 私は未来をつかんで、それをタスクの実行の開始を認識するデータ構造に入れようと考えていました。次に、専用のスレッドまたはプールを用意して、データ構造をループし、future.isDoneまたはタイムアウトの制限を超えているかどうかを確認します。はいの場合、結果を取得するか、実行を取り消すことができます。この方法では、多くのスレッドが必要ではありません。正しい実装か、まったくお勧めできませんか？

ありがとうございます。

編集：

ただ、多くのコンテキストを提供します。これらのスレッドは、ダウンストリームサービスへのロギングに使用されます。私たちは実際に応答に気にしませんが、接続が掛かっていることを望んでいません。したがって、未来をつかみ、それがキャンセルされるかタイムアウトすることを確実にする必要があります。

ここに質問をした後に書いた基本的なシミュレーションです。

@Component 
public class PollingService { 

    private ExecutorService executorService = Executors.newFixedThreadPool(1); 
    PoorMultiplexer poorMultiplexer = new PoorMultiplexer(); 
    private ConcurrentMap<Integer, Map<Future, Long>> futures = new ConcurrentHashMap<>(); 

    public void startHandler(){ 
     Thread handler = new Thread(new Runnable() { 
      @Override 
      public void run() { 
       while(true){ 
        try { 
         //This should be handled better. If there is not anything stop and re-start it later. 
         Thread.sleep(200); 
        } catch (InterruptedException e) { 
         e.printStackTrace(); 
        } 
        for(Iterator<ConcurrentMap.Entry<Integer, Map<Future, Long>>> it = futures.entrySet().iterator(); it.hasNext();){ 
         ConcurrentMap.Entry<Integer, Map<Future, Long>> entry = it.next(); 
         Map<Future, Long> futureMap = entry.getValue(); 
         boolean isProcessed = false; 
         if(futureMap.keySet().iterator().next().isDone()){ 
          //mark completed 
          isProcessed = true; 
         } 

         if(futureMap.values().iterator().next() < (300 + System.currentTimeMillis()) && !isProcessed){ 
          //cancel 
          futureMap.keySet().iterator().next().cancel(true); 
          isProcessed = true; 
         } 

         if(isProcessed){ 
          futures.remove(entry.getKey()); 
          System.out.println("Completed : " + entry.getKey()); 
         } 

        } 

        System.out.println("Run completed"); 
       } 
      } 
     }); 

     handler.start(); 
    } 

    public void run(int i) throws InterruptedException, ExecutionException{ 
     System.out.println("Starting : " + i); 

     poorMultiplexer.send(new Runnable() { 
      @Override 
      public void run() { 
       long startTime = System.currentTimeMillis(); 
       Future future = poorMultiplexer.send(execute()); 

       Map<Future, Long> entry = new HashMap<>(); 
       entry.put(future, startTime); 
       futures.put(i, entry); 
       System.out.println("Added : " + i); 
      } 
     }); 
    } 

    public void stop(){ 
     executorService.shutdown(); 
    } 

    public Runnable execute(){ 
     Worker worker = new Worker(); 
     return worker; 
    } 
} 


//This is a placeholder for a framework 
class PoorMultiplexer { 
    private ExecutorService executorService = Executors.newFixedThreadPool(20); 

    public Future send(Runnable task){ 
     return executorService.submit(task); 
    } 
} 


class Worker implements Runnable{ 

    @Override 
    public void run() { 
     //service call here 
    } 

} 

Answer 1

個別のスレッドを使用して未処理の一連のFuturesを非公式にポーリングすることは、私にとって妥当な実装のように聞こえます。つまり、ライブラリの依存関係を追加することができれば、Guavaは非同期作業を行うための豊富なユーティリティを提供しているため、GuavaのListenableFutureに簡単に切り替えることができます。