web-dev-qa-db-ja.com

Javaでタイムアウトを使用していくつかのブロッキングメソッドを呼び出すにはどうすればよいですか？

Javaでタイムアウトを使用してブロッキングメソッドを呼び出す標準的なニースの方法はありますか？私ができるようにしたい：

// call something.blockingMethod();
// if it hasn't come back within 2 seconds, forget it

それが理にかなっている場合。

ありがとう。

javaconcurrency
84
jjujuma

エグゼキューターを使用できます：

ExecutorService executor = Executors.newCachedThreadPool();
Callable<Object> task = new Callable<Object>() {
   public Object call() {
      return something.blockingMethod();
   }
};
Future<Object> future = executor.submit(task);
try {
   Object result = future.get(5, TimeUnit.SECONDS); 
} catch (TimeoutException ex) {
   // handle the timeout
} catch (InterruptedException e) {
   // handle the interrupts
} catch (ExecutionException e) {
   // handle other exceptions
} finally {
   future.cancel(true); // may or may not desire this
}

future.getは5秒後に戻りません。TimeoutExceptionをスローします。タイムアウトは、秒、分、ミリ秒、またはTimeUnitの定数として使用可能な任意の単位で構成できます。

詳細については、 JavaDoc を参照してください。

134
skaffman

呼び出しをFutureTaskでラップし、タイムアウトバージョンのget（）を使用できます。

http://Java.Sun.com/j2se/1.5.0/docs/api/Java/util/concurrent/FutureTask.html を参照してください

10
Colin Goudie

jcabi-aspects ライブラリを使用したAspectJソリューションもあります。

@Timeable(limit = 30, unit = TimeUnit.MINUTES)
public Soup cookSoup() {
  // Cook soup, but for no more than 30 minutes (throw and exception if it takes any longer
}

これ以上簡潔にすることはできませんが、もちろんAspectJに依存してビルドライフサイクルで導入する必要があります。

さらに説明する記事があります： Limit Java Method Execution Time

3
gvlasov

人々がこれを非常に多くの方法で実装しようとするのは本当に素晴らしいことです。しかし、真実は、方法はありません。

ほとんどの開発者は、ブロッキングコールを別のスレッドに入れ、将来または何らかのタイマーを設定しようとします。ただし、Javaでスレッドを外部で停止する方法はありません。スレッドの中断を明示的に処理するThread.sleep（）メソッドやLock.lockInterruptibly（）メソッドなどの非常に特殊なケースは言うまでもありません。

したがって、実際には3つの一般的なオプションしかありません。

  1. ブロッキングコールを新しいスレッドに配置し、時間が経過した場合は、先に進み、そのスレッドをハングさせます。その場合、スレッドがデーモンスレッドに設定されていることを確認する必要があります。この方法では、スレッドはアプリケーションの終了を停止しません。

  2. 非ブロッキングJava APIを使用します。そのため、たとえばネットワークの場合、NIO2を使用し、非ブロッキングメソッドを使用します。コンソールからの読み取りには、ブロッキング前にScanner.hasNext（）.

  3. ブロッキング呼び出しがIOではなくロジックである場合、Thread.isInterrupted()を繰り返しチェックして、外部から中断されたかどうかを確認し、ブロッキングスレッドで別のスレッドをthread.interrupt()呼び出します

並行性に関するこのコース https://www.udemy.com/Java-multithreading-concurrency-performance-optimization/?couponCode=CONCURRENCY

javaでどのように機能するかを本当に理解したい場合は、これらの基礎を実際に見ていきましょう。実際には、これらの特定の制限とシナリオ、および講義の1つでそれらをどのように進めるかについて説明しています。

私は個人的に、可能な限りブロッキング呼び出しを使用せずにプログラムしようとしています。たとえば、Vert.xのようなツールキットがあり、IOとno IO操作を非同期で、非ブロック方式で実行するのが本当に簡単でパフォーマンスが良くなります。

私はそれが役立つことを願っています

2
Michael P

Guavaの TimeLimiter も参照してください。これは、舞台裏で実行者を使用します。

2
Federico
Thread thread = new Thread(new Runnable() {
    public void run() {
        something.blockingMethod();
    }
});
thread.start();
thread.join(2000);
if (thread.isAlive()) {
    thread.stop();
}

停止は非推奨であることに注意してください。より良い代替方法は、次のように、blockingMethod（）内でいくつかの揮発性ブールフラグを設定してチェックして終了することです。

import org.junit.*;
import Java.util.*;
import junit.framework.TestCase;

public class ThreadTest extends TestCase {
    static class Something implements Runnable {
        private volatile boolean stopRequested;
        private final int steps;
        private final long waitPerStep;

        public Something(int steps, long waitPerStep) {
            this.steps = steps;
            this.waitPerStep = waitPerStep;
        }

        @Override
        public void run() {
            blockingMethod();
        }

        public void blockingMethod() {
            try {
                for (int i = 0; i < steps && !stopRequested; i++) {
                    doALittleBit();
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

        public void doALittleBit() throws InterruptedException {
            Thread.sleep(waitPerStep);
        }

        public void setStopRequested(boolean stopRequested) {
            this.stopRequested = stopRequested;
        }
    }

    @Test
    public void test() throws InterruptedException {
        final Something somethingRunnable = new Something(5, 1000);
        Thread thread = new Thread(somethingRunnable);
        thread.start();
        thread.join(2000);
        if (thread.isAlive()) {
            somethingRunnable.setStopRequested(true);
            thread.join(2000);
            assertFalse(thread.isAlive());
        } else {
            fail("Exptected to be alive (5 * 1000 > 2000)");
        }
    }
}
1
jnr

これを試して。よりシンプルなソリューション。ブロックが制限時間内に実行されなかった場合に保証します。プロセスは終了し、例外をスローします。

public class TimeoutBlock {

 private final long timeoutMilliSeconds;
    private long timeoutInteval=100;

    public TimeoutBlock(long timeoutMilliSeconds){
        this.timeoutMilliSeconds=timeoutMilliSeconds;
    }

    public void addBlock(Runnable runnable) throws Throwable{
        long collectIntervals=0;
        Thread timeoutWorker=new Thread(runnable);
        timeoutWorker.start();
        do{ 
            if(collectIntervals>=this.timeoutMilliSeconds){
                timeoutWorker.stop();
                throw new Exception("<<<<<<<<<<****>>>>>>>>>>> Timeout Block Execution Time Exceeded In "+timeoutMilliSeconds+" Milli Seconds. Thread Block Terminated.");
            }
            collectIntervals+=timeoutInteval;           
            Thread.sleep(timeoutInteval);

        }while(timeoutWorker.isAlive());
        System.out.println("<<<<<<<<<<####>>>>>>>>>>> Timeout Block Executed Within "+collectIntervals+" Milli Seconds.");
    }

    /**
     * @return the timeoutInteval
     */
    public long getTimeoutInteval() {
        return timeoutInteval;
    }

    /**
     * @param timeoutInteval the timeoutInteval to set
     */
    public void setTimeoutInteval(long timeoutInteval) {
        this.timeoutInteval = timeoutInteval;
    }
}

例：

try {
        TimeoutBlock timeoutBlock = new TimeoutBlock(10 * 60 * 1000);//set timeout in milliseconds
        Runnable block=new Runnable() {

            @Override
            public void run() {
                //TO DO write block of code 
            }
        };

        timeoutBlock.addBlock(block);// execute the runnable block 

    } catch (Throwable e) {
        //catch the exception here . Which is block didn't execute within the time limit
    }
1
Niroshan Abeywickrama

ここで完全なコードを提供します。私が呼び出しているメソッドの代わりに、メソッドを使用できます：

public class NewTimeout {
    public String simpleMethod() {
        return "simple method";
    }

    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadScheduledExecutor();
        Callable<Object> task = new Callable<Object>() {
            public Object call() throws InterruptedException {
                Thread.sleep(1100);
                return new NewTimeout().simpleMethod();
            }
        };
        Future<Object> future = executor.submit(task);
        try {
            Object result = future.get(1, TimeUnit.SECONDS); 
            System.out.println(result);
        } catch (TimeoutException ex) {
            System.out.println("Timeout............Timeout...........");
        } catch (InterruptedException e) {
            // handle the interrupts
        } catch (ExecutionException e) {
            // handle other exceptions
        } finally {
            executor.shutdown(); // may or may not desire this
        }
    }
}
1
VickyCool

GitHubの failsafe プロジェクトに存在するような サーキットブレーカー 実装が必要です。

0
Marco Montel

blockingMethodが数ミリだけスリープすると仮定します。

_public void blockingMethod(Object input) {
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
_

私の解決策は、次のようにwait()とsynchronizedを使用することです。

_public void blockingMethod(final Object input, long millis) {
    final Object lock = new Object();
    new Thread(new Runnable() {

        @Override
        public void run() {
            blockingMethod(input);
            synchronized (lock) {
                lock.notify();
            }
        }
    }).start();
    synchronized (lock) {
        try {
            // Wait for specific millis and release the lock.
            // If blockingMethod is done during waiting time, it will wake
            // me up and give me the lock, and I will finish directly.
            // Otherwise, when the waiting time is over and the
            // blockingMethod is still
            // running, I will reacquire the lock and finish.
            lock.wait(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
_

だからあなたは交換することができます

something.blockingMethod(input)

に

something.blockingMethod(input, 2000)

それが役に立てば幸い。

0
Euporie