限制Java中方法的执行时间

Question

I want to restrict the execution time of a method in java, I want my particular method that If it is executed in some certain defined time then ok otherwise it should throw an exception.

For this I tried using as :

@Timeable(limit = 1000, unit = TimeUnit.MILLISECONDS)
public void testMethod(){
    try {
            Thread.sleep(2000);
            if (Thread.interrupted()) {
                  throw new InterruptedException();
            }
        }catch(InterruptedException e1){
            logger.error("failed due to-" + e1, e1.getMessage());
            throw new InterruptedException(e1.getMessage());
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            throw new Exception(e.getMessage());
        }
}

For this I took reference from : http://www.yegor256.com/2014/06/20/limit-method-execution-time.html

It should throw the exception after the line:

Thread.sleep(2000);

But this my code is not throwing the exception.

Please help what is missing.

Thanks in advance for any other suggested approach for the same purpose.

Answer 1

For the approach you're using, it isn't sufficient to add @Timeable annotations, you also need to configure aspect weaving as described on Weaving Java Binaries .

It's interesting to note that the blog post author and creator of jcabi-aspects , Yegor Bugayenko, has since decided that Java annotations are a big mistake .

Another approach is to use CompletableFuture :

public void testMethod() {
    CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("Interrupted", e);
        }
    });
    try {
        future.get(1000, TimeUnit.MILLISECONDS);
    } catch (TimeoutException e) {
        // Operation timed out. Cancel it and log.
        future.cancel(true);
        logger.error("Timed out", e);
    } catch (InterruptedException e) {
        // Current thread interrupted while waiting. Cancel operation and log.
        future.cancel(true);
        logger.error("Interrupted", e);
        // Reassert interrupt flag, since exception is not propagated.
        Thread.currentThread().interrupt();
    } catch (ExecutionException e) {
        logger.error("Operation failed", e.getCause());
        // No need to cancel in this case, since the operation has completed.
    }
}

Note that the code always reasserts interrupt status when catching InterruptedException . See Why invoke Thread.currentThread.interrupt() in a catch InterruptException block?

Also note that the operation is explicitly cancelled if it times out or the calling thread is interrupted, to avoid wasting resources.

Answer 2

As already mentioned in the comments, this solution seems to be usuable in your case as well. It would look like this:

public void testMethod() {
    ForkJoinPool forkJoinPool = new ForkJoinPool(1);
    try {
        forkJoinPool.submit(() ->
        {
        // replace the following linea with the actual code that should be in this method
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {}
            System.out.println("Job done");
        })
        // wait for x milliseconds before wait times out and TimeOutException is thrown
                .get(1000, TimeUnit.MILLISECONDS);
    } catch (TimeoutException e) {
        // job not done in your interval
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    } 
}

Since the Thread#sleep takes 2 seconds, which is more than the 1 second wait time out specified in the .get(...) , this method will always time out in this example.

Answer 3

Here is the code and its self explanatory: For testing purpose I have just written s simple method that will execute for only 3 seconds.

import java.util.Timer;
import java.util.TimerTask;

class Test {

    Timer timer;

    public Test(int seconds) {
        timer = new Timer();
        timer.schedule(new RemindTask(), seconds * 1000);
    }

    class RemindTask extends TimerTask {
        public void run() {
            System.out.format("Time's up!%n");
            System.exit(0);
            timer.cancel();
        }
    }

    public static void main(String args[]) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                 new Test(3);
                 sum();
                 System.out.format("Task scheduled.%n");
            }
        });
       t.start();
    }

    public static void sum(){
        for(int i = 0 ; i < 100 ;i++){
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(i);
        }
    }
}