从多个线程调用时Thread.sleep（）如何工作

Question

sleep() is a static method of class Thread. How does it work when called from multiple threads. and how does it figure out the current thread of execution. ?

or may be a more generic Question would be How are static methods called from different threads ? Won't there be any concurrency problems ?

Answer 1

how does it figure out the current thread of execution?

It doesn't have to. It just calls the operating system, which always sleeps the thread that called it.

Answer 2

The sleep method sleeps the current thread so if you are calling it from multiple threads it will sleep each of those threads. Also there's the currentThread static method which allows you to get the current executing thread.

Answer 3

a more generic Question would be How are static methods called from different threads ? Won't there be any concurrency problems ?

There is only a potential concurrency problem if one or more thread modifies shared state while another thread uses the same state. There is no shared state for the sleep() method.

Answer 4

Thread.sleep(long) is implemented natively in the java.lang.Thread class. Here's a part of its API doc:

 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. The thread 
 does not lose ownership of any monitors.

The sleep method sleeps the thread that called it.(Based on EJP's comments) determines the currently executing thread (which called it and cause it to sleep). Java methods can determine which thread is executing it by calling Thread.currentThread()

Methods (static or non static) can be called from any number of threads simultaneously. Threre will not be any concurrency problems as long as your methods are thread safe . You will have problems only when multiple Threads are modifying internal state of class or instance without proper synchronization.

Answer 5

When the virtual machine encounters a sleep(long) -statement, it will interrupt the Thread currently running. "The current Thread" on that moment is always the thread that called Thread.sleep() . Then it says:

Hey! Nothing to do in this thread (Because I have to wait). I'm going to continue an other Thread.

Changing thread is called "to yield". (Note: you can yield by yourself by calling Thread.yield(); )

So, it doesn't have to figure out what the current Thread is. It is always the Thread that called sleep(). Note: You can get the current thread by calling Thread.currentThread();

A short example:

// here it is 0 millis
blahblah(); // do some stuff
// here it is 2 millis
new Thread(new MyRunnable()).start(); // We start an other thread
// here it is 2 millis
Thread.sleep(1000);
// here it is 1002 millis

MyRunnable its run() method:

// here it is 2 millis; because we got started at 2 millis
blahblah2(); // Do some other stuff
// here it is 25 millis;
Thread.sleep(300); // after calling this line the two threads are sleeping...
// here it is 325 millis;
... // some stuff
// here it is 328 millis;
return; // we are done;