CODEWITHSUNDEEP
javamultithreadingconcurrencythread-sleep
Mouhyi
Mouhyi

Reputation: 377

Thread.sleep behaving weirdly

I have the following code:

public Move chooseMove(Board board) {

    // start parallel thread
    this.tn = new TreeNode(this.myboard, this, null);
    tn.stop = false;
    this.curT = (new Thread(tn));
    this.curT.start();


    try {
        long startTime = System.currentTimeMillis();
        Thread.sleep(4000 );
        System.out.println(System.currentTimeMillis() - startTime);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        tn.stop=true;
        return getBestMove();
    }
}

The output is sometimes a value that is way greater than 4000ms like 5400ms which means that the thread is sleeping more than it should. Any help? Thanks.

EDIT: I understand that there is NO guarantee of Thread#sleep stoping precisely after the specified delay. However, an additional 1400ms is a long delay. Basically,I am implementing a game player agent and I need a way to run a task and then return a value to the server after 5s (or else the server ends the game). The server is using java.util.Timer.schedule(TimerTask task, long delay). There is only one thread running concurent to the main thread which is this.curT in the code above, so there is ins't really heavy multithreading.

Upvotes: 0

Views: 215

Answers (3)

Vito Gentile
Vito Gentile

Reputation: 14366

From docs.oracle.com:

Two overloaded versions of sleep are provided: one that specifies the sleep time to the millisecond and one that specifies the sleep time to the nanosecond. However, these sleep times are not guaranteed to be precise, because they are limited by the facilities provided by the underlying OS. Also, the sleep period can be terminated by interrupts, as we'll see in a later section. In any case, you cannot assume that invoking sleep will suspend the thread for precisely the time period specified.

Upvotes: 2

Cratylus
Cratylus

Reputation: 54074

Thread#sleep will make your thread sleep for exactly 4 seconds and then wake up.
Once your thread has woken up the OS scheduler places it in the runnable queue.
When it is next picked by the scheduler it will become a running thread i.e. will occupy the CPU.
So there is an additional delay overhead due to the OS scheduler which can vary per OS, system load etc. This is unrelated to Java

Upvotes: 1

Luiggi Mendoza
Luiggi Mendoza

Reputation: 85779

This is common behavior and it is described in Thread#sleep javadoc:

Causes the currently executing thread to sleep (temporarily cease execution) for the specified number of milliseconds, subject to the precision and accuracy of system timers and schedulers.

Based on this, there's no guarantee of Thread#sleep stoping the work of the thread by the amount of milliseconds stated in the parameter.

Upvotes: 1

Related Questions