How to stop excuting a method after say 1 sec. of time?

Question

I have a method in java which calls webservice. Now if the webservice is taking more than 1 sec. of time. I should be able to kill the method and continue in the program flow.

Answer 1

Google Guava's SimpleTimeLimiter will do what you need, specifically its callWithTimeout() method.

Answer 2

I would recommend you to use the Executors framework and call Future.get(long, TimeUnit). As for killing that call, you can call Future.cancel(true). Of course, you'll have to submit a Callable that contains the call.

Answer 3

In case you don't want to add a new library, you can easily accomplish this by delegating the Web Service invocation to another Thread, and join on it using a timeout of 1 sec. Below is a complete program which does these tasks. There are 2 key points:

1. Use Asynchronous Thread to do the call and join on it with TimeOut. You can additionally set it as Daemon.
2. Convey to the Asynchronous thread when the value from operation doesn't need to be consumed, so that it doesn't make unnecessary assignments.

Code:

public class Main {

String returnVar;
private static final long TIME_OUT=1000;//in mills
private void makeCall() {
    WebServiceStubDummy ws = new WebServiceStubDummy();
    Boolean timeElapsed = false;
    Thread t = new Thread(new AsyncWSCall(ws,timeElapsed));
    t.start();
    try {
        t.join(TIME_OUT);
    } catch (InterruptedException e) {}
    synchronized (ws) {
        timeElapsed=true;
    }
    System.out.println(returnVar);
}

private class AsyncWSCall implements Runnable{
    WebServiceStubDummy ws;
    Boolean timeElapsed;

    public AsyncWSCall(WebServiceStubDummy ws,  Boolean timeElapsed){
        this.ws=ws;
        this.timeElapsed=timeElapsed;
    }

    @Override
    public void run() {
        String myStr = ws.dummyMethod();
        //synchronize for shared variable timeElapsed
        synchronized (ws) {
            if(!timeElapsed){
                //if time elapsed don't assign
                returnVar=myStr;
            }
        }
    }       
}

class WebServiceStubDummy{
    public String dummyMethod(){
        try {
            //Dummy Call: if changed to 2000 value will not be consumed
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "From Dummy Metho";
    }
}


/**
 * @param args
 */
public static void main(String[] args) {
    Main m=new Main();
    m.makeCall();
}}

You can additionally fine tune your code as per how you wish to pass the WebService object and how you want to assign the result of WS operation

Answer 4

Use a timeout of 1 sec. on your webservice request.

Answer 5

The SO-thread "Killing thread after some specified time limit in java" could help. It makes use of ExecutorService

Time Limitation on method execution in java could also be used. Keep in mind though that Thread.stop is deprecated:

Why is Thread.stop deprecated?

Because it is inherently unsafe. Stopping a thread causes it to unlock all the monitors that it has locked. (The monitors are unlocked as the ThreadDeath exception propagates up the stack.) If any of the objects previously protected by these monitors were in an inconsistent state, other threads may now view these objects in an inconsistent state. Such objects are said to be damaged. When threads operate on damaged objects, arbitrary behavior can result. This behavior may be subtle and difficult to detect, or it may be pronounced. Unlike other unchecked exceptions, ThreadDeath kills threads silently; thus, the user has no warning that his program may be corrupted. The corruption can manifest itself at any time after the actual damage occurs, even hours or days in the future.

source: Java Thread Primitive Deprecation