如果程序在n秒后未返回任何内容，如何在Java中调用函数

Question

I have a function like this:

public boolean doLogin() {
    try {
        somemethodForLogin();
        return true;
    }  catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

In this case I want to return false or throw an exception if somemethodForLogin() takes more time than expected, say 8 seconds. How can I do this?

I added something like this just before somemethodForLogin() :

new java.util.Timer().schedule(
    new java.util.TimerTask() {
        @Override
        public void run() {
            System.out.println("Returning after 8 seconds wait");
        }
    }, 8000);

But it comes into this always, even if the call is success.

Answer 1

You can use a completable future to call the login, then retrieve the result with a timeout:

try {
    CompletableFuture.runAsync(() -> somemethodForLogin())
                 .get(8, TimeUnit.SECONDS);
    return true;
}catch(TimeoutException timeoutException) {
    //Timeout handline here
    return false; //or call other function
}

The above lambda is a Supplier rather than a Runnable .

CompletableFuture's get method is documented with the following:

Waits if necessary for at most the given time for this future to complete, and then returns its result, if available.
TimeoutException - if the wait timed out

EDIT:
The above is using CompletableFuture<Void> as the call is taking a Runnable . If somemethodForLogin() returns a value, you can use the same API, but calling supplyAsync :

Object loginResult = CompletableFuture.supplyAsync(() -> somemethodForLogin())
        .get(8, TimeUnit.SECONDS);
//Just change the return types accordingly.

Answer 2

So i have just created a sample program to solve your problem .I think that it works as expected but you could also tried it at your side.

I have explained the code in the code comments so it is not a code dump.

class Test
{
    // your do logic method 
    public boolean doLogic()
    {
        try{
            //New Thread for logic();
            Thread t1=new Thread(new Runnable() {
                        public void run() {
                            // calling your logic function in  a new thread
                            try{login();}catch(Exception e){e.printStackTrace();}
                        }
                    });
            t1.start();

            //Making the current thread to sleep for 8 seconds.
            Thread.sleep(8000);
            //check if t1 has ended  within 8 seconds, and then return the required value
            if(!t1.isAlive())
                return true;
            else
                return false;
        }
        catch(Exception e)
        {
            e.printStackTrace();
            return false;
        }
    }

    void login()throws Exception
    {
        Thread.sleep(9000);//tweak this value sleeps the t1 thread for a specific time just to simulate the login function
    }
    // driver method
    public static void main(String args[])
    {
        System.out.println(new Test().doLogic());

    }
}

Answer 3

Both answers allow a possibility for a denial of service attack by repeated login requests. As the executing thread will still continue to execute after 8 seconds, firing repeated login attempts would keep creating threads that would eat away the resources. The CompletableFuture approach would fill up the common pool, which wouldn't keep creating threads, but it would affect every other part of the code that uses the common pool.

What you can do is create a secondary pool with one or just a few connections dedicated to logging in. Set the connection checkout timeout to 8 seconds, and you've got your timeout there right out of the box. Not to mention less competition on the pool that's doing business tasks.