Programming Priorities

[Previous] [Next]

So how is a process assigned a priority class? Well, when you call CreateProcess, you can pass the desired priority class in the fdwCreate parameter. The table below shows the priority class identifiers.

Priority Class	Symbolic Identifiers
Real-time	REALTIME_PRIORITY_CLASS
High	HIGH_PRIORITY_CLASS
Above normal	ABOVE_NORMAL_PRIORITY_CLASS
Normal	NORMAL_PRIORITY_CLASS
Below normal	BELOW_NORMAL_PRIORITY_CLASS
Idle	IDLE_PRIORITY_CLASS

It might seem odd that the process that creates a child process chooses the priority class at which the child process runs. Let's consider Explorer as an example. When you use Explorer to run an application, the new process runs at normal priority. Explorer has no idea what the process does or how often its threads need to be scheduled. However, once the child process is running, it can change its own priority class by calling SetPriorityClass:

 BOOL SetPriorityClass( HANDLE hProcess, DWORD fdwPriority); 

This function changes the priority class identified by hProcess to the value specified in the fdwPriority parameter. The fdwPriority parameter can be one of the identifiers shown in the table above. Because this function takes a process handle, you can alter the priority class of any process running in the system as long as you have a handle to it and sufficient access.

Normally, a process will attempt to alter its own priority class. Here is an example of how to have a process set its own priority class to idle:

 BOOL SetPriorityClass( GetCurrentProcess(), IDLE_PRIORITY_CLASS); 

Here is the complementary function used to retrieve the priority class of a process:

 DWORD GetPriorityClass(HANDLE hProcess); 

As you might expect, this function returns one of the identifiers listed in the table above.

When you invoke a program using the command shell, the program's starting priority is normal. However, if you invoke the program using the Start command, you can use a switch to specify the starting priority of the application. For example, the following command entered at the command shell causes the system to invoke the Calculator and initially run it at idle priority:

 C:\>START /LOW CALC.EXE 

The Start command also recognizes the /BELOWNORMAL, /NORMAL, /ABOVENORMAL, /HIGH, and /REALTIME switches to start executing an application at their respective priority classes. Of course, once an application starts executing, it can call SetPriorityClass to alter its own priority to whatever it chooses.

Windows 98

---

The Windows 98 Start command does not support any of these switches. Processes started from the Windows 98 command shell always run using the normal priority class.

The Windows 2000 Task Manager allows the user to change the priority class of a process. The figure below shows the Task Manager's Processes tab, which shows all the processes currently running. The Base Pri column shows each process's priority class. You can alter a process's priority class by selecting a process and then selecting an option from the context menu's Set Priority submenu.

When a thread is first created, its relative thread priority is always set to normal. It has always seemed odd to me that CreateThread doesn't offer a way for the caller to set the new thread's relative priority. To set and get a thread's relative priority, you must call these functions:

 BOOL SetThreadPriority( HANDLE hThread, int nPriority); 

Of course, the hThread parameter identifies the single thread whose priority you want to change, and the nPriority parameter is one of the seven identifiers listed in the following table.

Relative Thread Priority	Symbolic Constant
Time-critical	THREAD_PRIORITY_TIME_CRITICAL
Highest	THREAD_PRIORITY_HIGHEST
Above normal	THREAD_PRIORITY_ABOVE_NORMAL
Normal	THREAD_PRIORITY_NORMAL
Below normal	THREAD_PRIORITY_BELOW_NORMAL
Lowest	THREAD_PRIORITY_LOWEST
Idle	THREAD_PRIORITY_IDLE

Here is the complementary function for retrieving a thread's relative priority:

 int GetThreadPriority(HANDLE hThread); 

This function returns one of the identifiers listed in the table above.

To create a thread with an idle relative thread priority, you execute code similar to the following:

 DWORD dwThreadID; HANDLE hThread = CreateThread(NULL, 0, ThreadFunc, NULL, CREATE_SUSPENDED, &dwThreadID); SetThreadPriority(hThread, THREAD_PRIORITY_IDLE); ResumeThread(hThread); CloseHandle(hThread); 

Note that CreateThread always creates a new thread with a normal relative thread priority. To have the thread execute using idle priority, you pass the CREATE_SUSPENDED flag to CreateThread; this prevents the thread from executing any code at all. Then you call SetThreadPriority to change the thread to an idle relative thread priority. You then call ResumeThread so that the thread can be schedulable. You don't know when the thread will get CPU time, but the scheduler takes into account the fact that this thread has an idle thread priority. Finally, you close the handle to the new thread so that the kernel object can be destroyed as soon as the thread terminates.

NOTE

---

Windows does not offer a function that returns a thread's priority level. This omission is deliberate. Remember that Microsoft reserves the right to change the scheduling algorithm at any time. You should not design an application that requires specific knowledge of the scheduling algorithm. If you stick with process priority classes and relative thread priorities, your application should run well today and on future versions of the system.