Scheduling Priorities

Each thread is assigned a scheduling priority. The priority levels range from zero (lowest priority) to 31 (highest priority). Only the zero-page thread can have a priority of zero. The zero-page thread is a system thread.

The priority of each thread is determined by the following criteria:

• The priority class of its process

• The priority level of the thread within the priority class of its process

The priority class and priority level are combined to form the base priority of a thread.

Priority Class

Each process belongs to one of the following priority classes:

IDLE_PRIORITY_CLASS
NORMAL_PRIORITY_CLASS
HIGH_PRIORITY_CLASS
REALTIME_PRIORITY_CLASS

By default, the priority class of a process is NORMAL_PRIORITY_CLASS. Use the CreateProcess function to specify the priority class of a child process when you create it. Use SetPriorityClass to change the priority class of a process and GetPriorityClass to determine the current priority class of a process.

Processes that monitor the system, such as screen savers or applications that periodically update a display, should use IDLE_PRIORITY_CLASS. This prevents the threads of this process, which do not have high priority, from interfering with higher priority threads.

Use HIGH_PRIORITY_CLASS with care. If a thread runs at the highest priority level for extended periods, other threads in the system will not get processor time. If several threads are set at high priority at the same time, the threads lose their effectiveness. The high-priority class should be reserved for threads that must respond to time-critical events. If your application performs one task that requires the high-priority class while the rest of its tasks are normal priority, use SetPriorityClass to raise the priority class of the application temporarily; then reduce it after the time-critical task has been completed. Another strategy is to create a high-priority process that has all of its threads blocked most of the time, awakening threads only when critical tasks are needed. The important point is that a high-priority thread should execute for a brief time, and only when it has time-critical work to perform.

You should almost never use REALTIME_PRIORITY_CLASS, because this interrupts system threads that manage mouse input, keyboard input, and background disk flushing. This class can be appropriate for applications that "talk" directly to hardware or that perform brief tasks that should have limited interruptions.

Priority Level

The following are priority levels within each priority class

THREAD_PRIORITY_IDLE
THREAD_PRIORITY_LOWEST
THREAD_PRIORITY_BELOW_NORMAL
THREAD_PRIORITY_NORMAL
THREAD_PRIORITY_ABOVE_NORMAL
THREAD_PRIORITY_HIGHEST
THREAD_PRIORITY_TIME_CRITICAL

All threads are created using THREAD_PRIORITY_NORMAL. This means that the thread priority is the same as the process priority class. After you create a thread, use the SetThreadPriority function to adjust its priority relative to other threads in the process.

A typical strategy is to use THREAD_PRIORITY_ABOVE_NORMAL or THREAD_PRIORITY_HIGHEST for the process's input thread, to ensure that the application is responsive to the user. Background threads, particularly those that are processor intensive, can be set to THREAD_PRIORITY_BELOW_NORMAL or THREAD_PRIORITY_LOWEST, to ensure that they can be preempted when necessary. However, if you have a thread waiting for another thread with a lower priority to complete some task, be sure to block the execution of the waiting high-priority thread. To do this, use a wait function, critical section, or the Sleep function, SleepEx, or SwitchToThread function. This is preferable to having the thread execute a loop. Otherwise, the process may become deadlocked, because the thread with lower priority is never scheduled.

To determine the current priority level of a thread, use the GetThreadPriority function.

Base Priority

The priority level of a thread is determined by both the priority class of its process and its priority level. The priority class and priority level are combined to form the base priority of each thread.

The following table shows the base priority levels for combinations of priority class and priority value.

	Process Priority Class	Thread Priority Level
	IDLE_PRIORITY_CLASS, NORMAL_PRIORITY_CLASS, or HIGH_PRIORITY_CLASS	THREAD_PRIORITY_IDLE
	IDLE_PRIORITY_CLASS	THREAD_PRIORITY_LOWEST
	IDLE_PRIORITY_CLASS	THREAD_PRIORITY_BELOW_NORMAL
	IDLE_PRIORITY_CLASS	THREAD_PRIORITY_NORMAL
	Background NORMAL_PRIORITY_CLASS	THREAD_PRIORITY_LOWEST
	IDLE_PRIORITY_CLASS	THREAD_PRIORITY_ABOVE_NORMAL
	Background NORMAL_PRIORITY_CLASS	THREAD_PRIORITY_BELOW_NORMAL
	IDLE_PRIORITY_CLASS	THREAD_PRIORITY_HIGHEST
	Foreground NORMAL_PRIORITY_CLASS	THREAD_PRIORITY_LOWEST
	Background NORMAL_PRIORITY_CLASS	THREAD_PRIORITY_NORMAL
	Foreground NORMAL_PRIORITY_CLASS	THREAD_PRIORITY_BELOW_NORMAL
	NORMAL_PRIORITY_CLASS	THREAD_PRIORITY_ABOVE_NORMAL
	Foreground NORMAL_PRIORITY_CLASS	THREAD_PRIORITY_NORMAL
	NORMAL_PRIORITY_CLASS	THREAD_PRIORITY_HIGHEST
	Foreground NORMAL_PRIORITY_CLASS	THREAD_PRIORITY_ABOVE_NORMAL
	HIGH_PRIORITY_CLASS	THREAD_PRIORITY_LOWEST
	Foreground NORMAL_PRIORITY_CLASS	THREAD_PRIORITY_HIGHEST
	HIGH_PRIORITY_CLASS	THREAD_PRIORITY_BELOW_NORMAL
	HIGH_PRIORITY_CLASS	THREAD_PRIORITY_NORMAL
	HIGH_PRIORITY_CLASS	THREAD_PRIORITY_ABOVE_NORMAL
	IDLE_PRIORITY_CLASS, NORMAL_PRIORITY_CLASS, or HIGH_PRIORITY_CLASS	THREAD_PRIORITY_TIME_CRITICAL
	HIGH_PRIORITY_CLASS	THREAD_PRIORITY_HIGHEST
	REALTIME_PRIORITY_CLASS	THREAD_PRIORITY_IDLE
22	REALTIME_PRIORITY_CLASS	THREAD_PRIORITY_LOWEST
23	REALTIME_PRIORITY_CLASS	THREAD_PRIORITY_BELOW_NORMAL
24	REALTIME_PRIORITY_CLASS	THREAD_PRIORITY_NORMAL
25	REALTIME_PRIORITY_CLASS	THREAD_PRIORITY_ABOVE_NORMAL
26	REALTIME_PRIORITY_CLASS	THREAD_PRIORITY_HIGHEST
31	REALTIME_PRIORITY_CLASS	THREAD_PRIORITY_TIME_CRITICAL

Software for developers

Delphi Components
.Net Components
Software for Android Developers

More information resources

MegaDetailed.Net
Unix Manual Pages
Delphi Examples

Databases for Amazon shops developers

Amazon Categories Database
Browse Nodes Database