Thread methods in Java
On the previous page, we looked at how to
construct a thread in Java, via the Runnable and Thread objects. We mentioned
that the Thread class provides control over threads. So on this page,
we take a high-level look at the most important methods on this class.
We actually saw a sneak
preview of Thread.sleep() in our Java threading introduction.
This static method asks the system to put the current thread
to sleep for (approximately) the specified amount of time, effectively allowing us
to implement a "pause". A thread can be interrupted
from its sleep.
For more details, see: Thread.sleep() (separate page).
As mentioned, you can call a Thread object's interrupt() method
to interrupt the corresponding thread if it is sleeping or waiting. The corresponding
thread will "wake up" with an IOException at some point in the future.
See thread interruption for more details.
setPriority() / getPriority()
Sets and queries some platform-specific priority assignment of the given thread.
When calculating a priority value, it's good practice to always do so in relation to the
constants Thread.MIN_PRIORITY, Thread.NORM_PRIORITY and
Thread.MAX_PRIORITY. In practice, values go from 1 to 10, and map on to
some machine-specific range of values: nice values in the case of
Linux, and local thread priorities in the case of Windows. These are generally
the range of values of "normal" user threads, and the OS will actually still run
other threads beyond these values (so, for example, you can't preempt
the mouse pointer thread by setting a thread to MAX_PRIORITY!).
Three main issues with thread priorities are that:
- they don't always do what you might intuitively think they do;
- their behaviour depends on the platform and Java version:
e.g. in Linux, priorities don't work at all in Hotspot before Java 6, and
the mapping of Java to OS priorities changed under
Windows between Java 5 and Java 6;
- in trying to use them for some purpose, you may actually
interfere with more sensible scheduling decisions that the OS would have made anyway
to achieve your purpose.
For more information, see the section on
thread scheduling and the discussion on thread priorities, where
the behaviour on different platforms is compared.
The join() method is called on the Thread object representing
enother thread. It tells the current thread to wait for the other thread
to complete. To wait for multiple threads at a time, you can use a CountDownLatch.
This method effectively tells the system that the current thread is "willing to
relinquish the CPU". What it actually does is quite system-dependent.
For more details, see: Thread.yield() (separate page).
setName() / getName()
Threads have a name attached to them. By default, Java will attach a fairly dull
name such as Thread-12. But for debugging purposes you might want to
attach a more meaningful name such as Animation Thread, WorkerThread-10 etc.
(Some of the variants of the Thread constructor actually allow you to pass in a name
from the start, but you can always change it later.)
Other thread functions
There are occasionally other things that you may wish to do with a thread that
don't correspond to a single method. In particular, there is no
safe method to stop a thread, and instead you
should simply let the corresponding run() method exit.