How to stop code after Thread's sleep() method executing immediately

Question

I have attempted to pause the execution of part of my program for a few seconds by invoking the sleep() method of the Thread class. However, when I try this, the code that comes immediately after this invocation still executes immediately. For instance, if I have the code:

Thread compoundThread = new Thread(new Runnable()
{                       
    public void run() 
    {
        try 
        {
            Thread.currentThread().sleep(2000);
        } 
        catch (InterruptedException e) 
        {
            // TODO Auto-generated catch block
            Thread.currentThread().interrupt();
        }               
    }

});

compoundThread.start();

System.out.println("line 15")

Line 15 just prints immediately. Is there a way around this problem? I thought the whole idea of the sleep() method was to pause execution.

Edit in response to Philipp's comment

while (totalNoOfPhase1Trials > 399)
{           //
                Phase1Trial phase1Trial = new Phase1Trial(numberOfElements, elementColors);

                displayComplexStimulus(phase1Trial.getComplexStimulus());
                validate();

                Thread compoundThread = new Thread(new Runnable(){

                    public void run() {
                        try {
                            Thread.currentThread().sleep(2000);
                            System.out.println("line 226");
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block

                        }


                    }

                });



                compoundThread.start();     
                try {
                    compoundThread.join();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

The displayCompoundStimulus method displays a set of jlabels with no delay when I don't include the code you just mentioned where I put the thread to sleep. However, when I include the code that puts the thread to sleep, the display of images gets delayed by two seconds as well, which is strange given that Thread.sleep() gets executed AFTER the images are displayed.

Answer 1

The code behaves as implemented. You are running your main thread, which starts another thread, which sleeps for 2000ms.

So your main thread does:

1. start the compoundThread
2. print out
3. finish main thread

Depending on what you want to achieve, you could just remove the whole thread and do:

try {
   Thread.sleep(2000);
} catch (InterruptedException e) {
   // should not happen, you don't interrupt                     
}
System.out.println("line 15");

Otherwise you can move the output into the thread's run method:

Thread compoundThread = new Thread(new Runnable(){

    public void run() {
        try {
            Thread.sleep(2000);
            System.out.println("line 15");
        } catch (InterruptedException e) {
            // do whatever has to be done
        }
    }
});

compoundThread.start();

// you might want to wait until compoundThread is done
compoundThread.join();

UPDATE: Based on your comment regarding the delayed output

If you use the following code:

public static void main(String[] args) {
    System.out.println("Hello");
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        // should not happen, you don't interrupt
    }
    System.out.println("World");
}

The output will be "Hello" and two seconds after that "World". The thread will sleep for exactly two seconds.

Answer 2

The main thread is the one that starts running your main method.

Your main method then creates a new Thread object and invokes compoundThread.start();, which causes the second thread to begin execution.

Immediately afterwards, without stopping the main thread continues execution and arrives at the print statement. Thus line 15 is being printed by the main thread.

The secnond thread you started sleeps for 2 seconds and then terminates. If you had put the print statement in the thread's run method after the sleep call, then there would have been a 2 second pause before printing line 15.

Answer 3

Here compoundThread is a new thread object. Your line 15 is executed through main method. So when you start compoundThread.start(), a new thread is created and started independently of your main thread.

If you want to slow down your main thread, just use Thread.sleep(2000) on outside the runnable object code.

Answer 4

Your original thread (main thread) starts a new thread, and the new thread sleeps for two seconds. The original thread doesn’t, which is why it prints "Line 15" immediately. So Sandeep’s suggestion, though terse, should work if you understand and apply it correctly. One other obvious possibility is to put the System.out.println statement inside the run method of the compoundThread.

Answer 5

Screenshot

have a view & tell me wheather it worked or not

Answer 6

I suggest you to use simple

thread.sleep(2000)