In diesem Artikel werden wir das Multithreading-Modell im Betriebssystem verstehen.
Multithreading-Modell:
Multithreading ermöglicht es der Anwendung, ihre Aufgabe in einzelne Threads aufzuteilen. Bei Multithreads kann derselbe Prozess oder dieselbe Aufgabe durch die Anzahl der Threads ausgeführt werden, oder wir können sagen, dass es beim Multithreading mehr als einen Thread gibt, der die Aufgabe ausführt. Durch den Einsatz von Multithreading kann Multitasking erreicht werden.
groovige Sprache
Der Hauptnachteil von Single-Threading-Systemen besteht darin, dass jeweils nur eine Aufgabe ausgeführt werden kann. Um den Nachteil dieses Single-Threadings zu überwinden, gibt es Multithreading, das die Ausführung mehrerer Aufgaben ermöglicht.
Zum Beispiel:
Im obigen Beispiel greifen Client1, Client2 und Client3 ohne Wartezeit auf den Webserver zu. Beim Multithreading können mehrere Aufgaben gleichzeitig ausgeführt werden.
In einem Betriebssystem werden Threads in den Thread auf Benutzerebene und den Thread auf Kernelebene unterteilt. Threads auf Benutzerebene wurden unabhängig vom Kernel verwaltet und daher ohne jegliche Kernel-Unterstützung verwaltet. Im Gegensatz dazu verwaltet das Betriebssystem die Threads auf Kernelebene direkt. Dennoch muss eine Beziehung zwischen Threads auf Benutzerebene und Kernelebene bestehen.
Es gibt drei etablierte Multithreading-Modelle, die diese Beziehungen klassifizieren:
- Viele-zu-eins-Multithreading-Modell
- Eins-zu-eins-Multithreading-Modell
- Viele-zu-viele-Multithreading-Modelle
Viele-zu-eins-Multithreading-Modell:
Das Many-to-One-Modell ordnet viele Threads auf Benutzerebene einem Kernel-Thread zu. Diese Art von Beziehung ermöglicht eine effektive Kontextwechselumgebung, die selbst auf dem einfachen Kernel ohne Thread-Unterstützung problemlos implementiert werden kann.
Listensortierung Java
Der Nachteil dieses Modells besteht darin, dass dieses Modell die Hardwarebeschleunigung, die Multithread-Prozesse oder Multiprozessorsysteme bieten, nicht nutzen kann, da es jeweils nur einen Thread-Plan auf Kernel-Ebene gibt. Dabei erfolgt die gesamte Thread-Verwaltung im Userspace. Kommt es zu einer Blockierung, blockiert dieses Modell das gesamte System.
Sortieren in einer Liste in Java
In der obigen Abbildung ordnet das Viele-zu-Eins-Modell alle Threads auf Benutzerebene einzelnen Threads auf Kernelebene zu.
Eins-zu-eins-Multithreading-Modell
Das Eins-zu-eins-Modell ordnet einen einzelnen Thread auf Benutzerebene einem einzelnen Thread auf Kernelebene zu. Diese Art von Beziehung erleichtert die parallele Ausführung mehrerer Threads. Dieser Vorteil bringt jedoch auch Nachteile mit sich. Die Generierung jedes neuen Benutzer-Threads muss die Erstellung eines entsprechenden Kernel-Threads umfassen, was einen Overhead verursacht, der die Leistung des übergeordneten Prozesses beeinträchtigen kann. Windows-Serien und Linux-Betriebssysteme versuchen, dieses Problem zu lösen, indem sie das Wachstum der Thread-Anzahl begrenzen.
In der obigen Abbildung ordnet ein Modell diesen einen Thread auf Benutzerebene einem einzelnen Thread auf Kernelebene zu.
Viele-zu-viele-Modell-Multithreading-Modell
In diesem Modelltyp gibt es mehrere Threads auf Benutzerebene und mehrere Threads auf Kernelebene. Die Anzahl der erstellten Kernel-Threads hängt von einer bestimmten Anwendung ab. Der Entwickler kann auf beiden Ebenen beliebig viele Threads erstellen, die jedoch möglicherweise unterschiedlich sind. Das Many-to-Many-Modell ist ein Kompromiss zwischen den beiden anderen Modellen. Wenn in diesem Modell ein Thread einen blockierenden Systemaufruf durchführt, kann der Kernel einen anderen Thread zur Ausführung einplanen. Außerdem ist durch die Einführung mehrerer Threads keine Komplexität mehr vorhanden wie bei den Vorgängermodellen. Obwohl dieses Modell die Erstellung mehrerer Kernel-Threads ermöglicht, kann mit diesem Modell keine echte Parallelität erreicht werden. Dies liegt daran, dass der Kernel jeweils nur einen Prozess planen kann.
Viele bis viele Versionen des Multithreading-Modells verknüpfen mehrere Threads auf Benutzerebene mit der gleichen oder einer viel geringeren Vielfalt an Threads auf Kernelebene in der obigen Abbildung.