Multithreading in Java - Setting Thread Priorities (Page 7 of 10 )
Previously in this chapter, you learned that each thread has an assigned priority that is used to let more important threads use resources ahead of lower-priority resources. Priority is used as a guide for the operating system to determine which thread gets accesses to a resource such as the CPU. In reality, an operating system takes other factors into consideration. Typically, programmers have little or no control over those other factors. Therefore, they establish a priority for their threads without further concern over those other factors.
A priority is an integer from 1 to 10 inclusive, where 10 is the highest priority, referred to as the maximum priority, and 1 is the lowest priority, also known as the minimum priority. The normal priority is 5, which is the default priority for each thread.
In general, a thread with a higher priority bumps a thread with a lower priority from using a resource. The lower-priority thread pauses until the higher-priority thread is finished using the resource. Whenever two threads of equal priority need the same resource, the thread that accesses the resource first has use of the resource. What happens to the second thread depends on the operating system under which your program is running. Some operating systems force the second thread to wait until the first thread is finished with the resource. Other operating systems require the first thread to give the second thread access to the resource after a specified time period. This is to ensure that one thread doesn’t hog a resource and prevent other threads from utilizing it.
In the real world, the first thread usually pauses while using the resource because another resource it needs isn’t available. It is during this pause that the operating system has the first thread relinquish the resource. The problem is, you don’t know if and when the pause will occur. It is best to always cause a thread to pause periodically whenever the thread is using a resource for a long period time. In this way, the thread shares the resource with other threads. You learn how to pause a thread in the “Suspending and Resuming a Thread” section of this chapter.
You need to keep in mind that there is a downside to periodically pausing a thread. Pausing a thread diminishes the performance of your program and could cause a backlog for use of the resource. Therefore, you need to monitor the performance of your program regularly to make sure you are not experiencing this negative aspect of pausing a thread.
For now let’s focus on something you do have control over—setting the priority of a thread. You set a thread’s priority by calling the setPriority() method, which is defined in the Thread class. The setPriority() method requires one parameter, which is the integer representing the level of priority. You have two ways in which to represent the priority. You can use an integer from 1 to 10, or you can use final variables defined in the Thread class. These variables are MIN_PRIORITY, MAX_PRIOIRTY, and NORM_PRIOIRTY.
You can determine the priority level of a thread by calling the getPriority() method, which is also defined in the Thread class. The getPriority() method does not requires an argument, and it returns the integer representing the level of priority for the thread.
The following example illustrates how to use the setPriority() and getPriority() methods. This example creates two child threads and sets the priority for each. First, the low-priority thread starts, followed by the high-priority thread. Here’s what is displayed when you run this program (notice that the high-priority thread runs ahead of the low-priority thread, even though the low-priority thread started first):
NOTE: The results displayed on your screen might be different from the results shown here because of the way your operating system handles thread priorities.
low priority started
high priority started
high priority running.
low priority running.
low priority stopped.
high priority stopped.
class MyThread implements Runnable {
Thread t;
private volatile boolean running = true;
public MyThread (int p, String tName) {
t = new Thread(this,tName);
t.setPriority (p);
}
public void run() {
System.out.println(t.getName() + " running.");
}
public void stop() {
running = false;
System.out.println(t.getName() + " stopped.");
}
public void start() {
System.out.println(t.getName() + " started");
t.start();
}
}
class Demo {
public static void main(String args[] ) {
Thread.currentThread().setPriority(10);
MyThread lowPriority =
new MyThread (3, "low priority");
MyThread highPriority =
new MyThread (7, "high priority");
lowPriority.start();
highPriority.start();
try {
Thread.sleep(1000);
} catch ( InterruptedException e) {
System.out.println("Main thread interrupted.");
}
lowPriority.stop();
highPriority.stop();
try {
highPriority.t.join();
lowPriority.t.join();
} catch (InterruptedException e) {
System.out.println(
"InterruptedException caught");
}
}
}
Next: Synchronizing Threads >>
More Java Articles
More By McGraw-Hill/Osborne
|
| · | | · | | · | | · | | · | | · | | · | | · | | · | | · | | · | | · | | · | | · | | · | | · | | · | | · | | · | | · | | · | | | | |
|
|
 This article is excerpted from chapter 10 of the book Java Demystified, written by Jim Keogh (McGraw-Hill/Osborne, 2004; ISBN: 0072254548). Check it out at your favorite bookstore today. Buy this book now.
|
|
/ 193 
