Planungsprioritäten
Die Ausführung von Threads wird basierend auf ihrer Planungspriorität geplant. Jedem Thread wird eine Planungspriorität zugewiesen. Die Prioritätsstufen reichen von null (niedrigste Priorität) bis 31 (höchste Priorität). Nur der Nullseitenthread kann eine Priorität von 0 haben. (Der Nullseitenthread ist ein Systemthread, der für das Nullen aller freien Seiten verantwortlich ist, wenn keine anderen Threads ausgeführt werden müssen.)
Das System behandelt alle Threads mit der gleichen Priorität als gleich. Das System weist Zeits slices auf Roundrobin-Weise allen Threads mit der höchsten Priorität zu. Wenn keiner dieser Threads zur Ausführung bereit ist, weist das System allen Threads Zeits slices auf Roundrobin-Weise mit der nächsthöheren Priorität zu. Wenn ein Thread mit höherer Priorität für die Ausführung verfügbar wird, beendet das System die Ausführung des Threads mit niedrigerer Priorität (ohne zuzulassen, dass es seinen Zeitslice beendet) und weist dem Thread mit höherer Priorität einen vollständigen Slice zu. Weitere Informationen finden Sie unter Kontextwechsel.
Die Priorität jedes Threads wird durch die folgenden Kriterien bestimmt:
- Die Prioritätsklasse des Prozesses
- Die Prioritätsebene des Threads innerhalb der Prioritätsklasse seines Prozesses
Die Prioritätsklasse und die Prioritätsebene werden kombiniert, um die Basispriorität eines Threads zu bilden. Informationen zur dynamischen Priorität eines Threads finden Sie unter Prioritätssteigerungen.
Prioritätsklasse
Jeder Prozess gehört zu einer der folgenden Prioritätsklassen:
- IDLE_PRIORITY_CLASS
BELOW_NORMAL_PRIORITY_CLASS
NORMAL_PRIORITY_CLASS
ABOVE_NORMAL_PRIORITY_CLASS
HIGH_PRIORITY_CLASS
REALTIME_PRIORITY_CLASS
Standardmäßig ist die Prioritätsklasse eines Prozesses NORMAL_PRIORITY_CLASS. Verwenden Sie die CreateProcess-Funktion , um die Prioritätsklasse eines untergeordneten Prozesses anzugeben, wenn Sie ihn erstellen. Wenn der aufrufende Prozess IDLE_PRIORITY_CLASS oder BELOW_NORMAL_PRIORITY_CLASS ist, erbt der neue Prozess diese Klasse. Verwenden Sie die GetPriorityClass-Funktion , um die aktuelle Prioritätsklasse eines Prozesses und die SetPriorityClass-Funktion zu bestimmen, um die Prioritätsklasse eines Prozesses zu ändern.
Prozesse, die das System überwachen, z. B. Bildschirmschoner oder Anwendungen, die eine Anzeige regelmäßig aktualisieren, sollten IDLE_PRIORITY_CLASS verwenden. Dadurch wird verhindert, dass die Threads dieses Prozesses, die keine hohe Priorität haben, Threads mit höherer Priorität stören.
Verwenden Sie HIGH_PRIORITY_CLASS sorgfältig. Wenn ein Thread für längere Zeiträume mit der höchsten Priorität ausgeführt wird, erhalten andere Threads im System keine Prozessorzeit. Wenn mehrere Threads gleichzeitig mit hoher Priorität festgelegt werden, verlieren die Threads ihre Effektivität. Die Klasse mit hoher Priorität sollte Für Threads reserviert werden, die auf zeitkritische Ereignisse reagieren müssen. Wenn Ihre Anwendung eine Aufgabe ausführt, die die Klasse mit hoher Priorität erfordert, während die restlichen Aufgaben normale Priorität haben, verwenden Sie SetPriorityClass , um die Prioritätsklasse der Anwendung vorübergehend anzuheben. reduzieren Sie sie dann, nachdem die zeitkritische Aufgabe abgeschlossen wurde. Eine weitere Strategie besteht darin, einen Prozess mit hoher Priorität zu erstellen, bei dem alle zugehörigen Threads die meiste Zeit blockiert werden und Threads nur dann aktiviert werden, wenn kritische Aufgaben erforderlich sind. Der wichtige Punkt ist, dass ein Thread mit hoher Priorität für eine kurze Zeit ausgeführt werden sollte, und zwar nur, wenn zeitkritische Arbeiten ausgeführt werden müssen.
Sie sollten fast nie REALTIME_PRIORITY_CLASS verwenden, da dadurch Systemthreads unterbrochen werden, die Mauseingaben, Tastatureingaben und Hintergrunddatenträgerleerungen verwalten. Diese Klasse kann für Anwendungen geeignet sein, die direkt mit Hardware "kommunizieren" oder kurze Aufgaben ausführen, die begrenzte Unterbrechungen aufweisen sollten.
Prioritätsebene
Die folgenden Prioritätsstufen sind innerhalb jeder Prioritätsklasse aufgeführt:
- THREAD_PRIORITY_IDLE
THREAD_PRIORITY_LOWEST
THREAD_PRIORITY_BELOW_NORMAL
THREAD_PRIORITY_NORMAL
THREAD_PRIORITY_ABOVE_NORMAL
THREAD_PRIORITY_HIGHEST
THREAD_PRIORITY_TIME_CRITICAL
Alle Threads werden mit THREAD_PRIORITY_NORMAL erstellt. Dies bedeutet, dass die Threadpriorität mit der Prozessprioritätsklasse identisch ist. Nachdem Sie einen Thread erstellt haben, verwenden Sie die SetThreadPriority-Funktion , um die Priorität relativ zu anderen Threads im Prozess anzupassen.
Eine typische Strategie besteht darin, THREAD_PRIORITY_ABOVE_NORMAL oder THREAD_PRIORITY_HIGHEST für den Eingabethread des Prozesses zu verwenden, um sicherzustellen, dass die Anwendung auf den Benutzer reagiert. Hintergrundthreads, insbesondere solche, die prozessorintensiv sind, können auf THREAD_PRIORITY_BELOW_NORMAL oder THREAD_PRIORITY_LOWEST festgelegt werden, um sicherzustellen, dass sie bei Bedarf vorbelastet werden können. Wenn jedoch ein Thread auf einen anderen Thread mit einer niedrigeren Priorität wartet, um eine Aufgabe auszuführen, müssen Sie die Ausführung des wartenden Threads mit hoher Priorität blockieren. Verwenden Sie hierzu eine Wartefunktion, einen kritischen Abschnitt oder die SleepEx- oder SwitchToThread-Funktion. Dies ist vorzuziehen, wenn der Thread eine Schleife ausführt. Andernfalls wird der Prozess möglicherweise deadlocked, da der Thread mit niedrigerer Priorität nie geplant ist.
Um die aktuelle Prioritätsebene eines Threads zu bestimmen, verwenden Sie die GetThreadPriority-Funktion .
Basispriorität
Die Prozessprioritätsklasse und die Threadprioritätsebene werden kombiniert, um die Basispriorität jedes Threads zu bilden.
Die folgende Tabelle zeigt die Basispriorität für Kombinationen von Prozessprioritätsklasse und Threadprioritätswert.
| Prozessprioritätsklasse | Threadprioritätsebene | Basispriorität | |
|---|---|---|---|
| IDLE_PRIORITY_CLASS | THREAD_PRIORITY_IDLE | 1 | |
| THREAD_PRIORITY_LOWEST | 2 | ||
| THREAD_PRIORITY_BELOW_NORMAL | 3 | ||
| THREAD_PRIORITY_NORMAL | 4 | ||
| THREAD_PRIORITY_ABOVE_NORMAL | 5 | ||
| THREAD_PRIORITY_HIGHEST | 6 | ||
| THREAD_PRIORITY_TIME_CRITICAL | 15 | ||
| BELOW_NORMAL_PRIORITY_CLASS | THREAD_PRIORITY_IDLE | 1 | |
| THREAD_PRIORITY_LOWEST | 4 | ||
| THREAD_PRIORITY_BELOW_NORMAL | 5 | ||
| THREAD_PRIORITY_NORMAL | 6 | ||
| THREAD_PRIORITY_ABOVE_NORMAL | 7 | ||
| THREAD_PRIORITY_HIGHEST | 8 | ||
| THREAD_PRIORITY_TIME_CRITICAL | 15 | ||
| NORMAL_PRIORITY_CLASS | THREAD_PRIORITY_IDLE | 1 | |
| THREAD_PRIORITY_LOWEST | 6 | ||
| THREAD_PRIORITY_BELOW_NORMAL | 7 | ||
| THREAD_PRIORITY_NORMAL | 8 | ||
| THREAD_PRIORITY_ABOVE_NORMAL | 9 | ||
| THREAD_PRIORITY_HIGHEST | 10 | ||
| THREAD_PRIORITY_TIME_CRITICAL | 15 | ||
| ABOVE_NORMAL_PRIORITY_CLASS | THREAD_PRIORITY_IDLE | 1 | |
| THREAD_PRIORITY_LOWEST | 8 | ||
| THREAD_PRIORITY_BELOW_NORMAL | 9 | ||
| THREAD_PRIORITY_NORMAL | 10 | ||
| THREAD_PRIORITY_ABOVE_NORMAL | 11 | ||
| THREAD_PRIORITY_HIGHEST | 12 | ||
| THREAD_PRIORITY_TIME_CRITICAL | 15 | ||
| HIGH_PRIORITY_CLASS | THREAD_PRIORITY_IDLE | 1 | |
| THREAD_PRIORITY_LOWEST | 11 | ||
| THREAD_PRIORITY_BELOW_NORMAL | 12 | ||
| THREAD_PRIORITY_NORMAL | 13 | ||
| THREAD_PRIORITY_ABOVE_NORMAL | 14 | ||
| THREAD_PRIORITY_HIGHEST | 15 | ||
| THREAD_PRIORITY_TIME_CRITICAL | 15 | ||
| REALTIME_PRIORITY_CLASS | THREAD_PRIORITY_IDLE | 16 | |
| THREAD_PRIORITY_LOWEST | 22 | ||
| THREAD_PRIORITY_BELOW_NORMAL | 23 | ||
| THREAD_PRIORITY_NORMAL | 24 | ||
| THREAD_PRIORITY_ABOVE_NORMAL | 25 | ||
| THREAD_PRIORITY_HIGHEST | 26 | ||
| THREAD_PRIORITY_TIME_CRITICAL | 31 | ||