Kann Multithreading auf einem Einzelprozessorsystem implementiert werden?

Ich bin immer dem Konzept gefolgt, dass Multithreading nur auf Systemen mit mehreren Prozessoren implementiert werden kann, bei denen jedem Thread mehr als ein Prozessor zugewiesen werden muss und jeder Thread gleichzeitig ausgeführt werden kann. In diesem Fall gibt es keine Planung, da jeder Thread separate Ressourcen hat, die alle ihm gewidmet sind. Aber ich habe kürzlich irgendwo gelesen, dass ich Multithreading auch auf einem Einzelprozessorsystem durchführen kann. Ist es richtig? und wenn ja, was ist dann der Unterschied zwischen Systemen mit einem Prozessor und mehreren Prozessoren?

Ich habe kürzlich irgendwo gelesen, dass ich Multithreading auch auf einem Einzelprozessorsystem ausführen kann. Ist es richtig? und wenn ja, was ist dann der Unterschied zwischen Systemen mit einem Prozessor und mehreren Prozessoren?

Ja, Sie können Multithreading auf einem Einzelprozessorsystem durchführen.

In Mehrprozessorsystemen werden mehrere Threads ausgeführt, gleichzeitig auf verschiedenen Kernen. Beispiel: Wenn zwei Threads und zwei Kerne vorhanden sind, wird jeder Thread auf einem einzelnen Kern ausgeführt.

In einem Einzelprozessorsystem werden mehrere Threads nacheinander ausgeführt oder warten, bis ein Thread beendet oder vom Betriebssystem unterbrochen wird, abhängig von der Thread-Priorität und der Betriebssystemrichtlinie. Aber die laufenden Threads erwecken die Illusion, dass sie gleichzeitig ausgeführt werden , relativ zur erforderlichen Reaktionszeit der Anwendung der Benutzerbereichsanwendung.

Zeitvergleich (Beispiel):

Wenn zwei Threads jeweils 10 us für die Ausführung benötigen, beträgt die Nettozeit auf einem 2-Prozessor-System 10 us

Wenn zwei Threads jeweils 10 us für die Ausführung benötigen, beträgt die Nettozeit auf einem 1-Prozessor-System 20 us

Natürlich geht das auch auf einem Einprozessorsystem, und tatsächlich ist es so viel einfacher. Es funktioniert genauso wie das Ausführen mehrerer Prozesse – der Kernel hält über einen Timer-Interrupt oder einen ähnlichen Mechanismus einen an, speichert seinen Maschinenzustand und ersetzt diesen durch den zuvor gespeicherten Zustand eines anderen – der einzige Unterschied sind diese beiden Threads desselben Prozesses teilen sich denselben virtuellen Speicherplatz, wodurch der Task-Wechsel viel effizienter wird.

Multi-Threading auf Mehrprozessorsystemen ist tatsächlich viel schwieriger, da Sie Probleme mit dem gleichzeitigen Zugriff auf den Speicher von mehreren CPUs/Kernen und all den unangenehmen Problemen mit der Speichersynchronisierung haben, die sich daraus ergeben.

Auf einem Quad-Core-System können mehr als vier aktive Threads vorhanden sein. Dort ist Scheduling, es sei denn, Sie können garantieren, dass Prozesse nicht versuchen, mehr Threads zu erstellen, als Prozessoren vorhanden sind.

Ja, Sie können mehrere Threads auf einem Single-Core-Computer haben.

Der Unterschied zwischen Einprozessor- und Mehrprozessorsystemen besteht darin, dass ein Mehrprozessorsystem tatsächlich mehr als eine Sache gleichzeitig erledigen kann. Es kann N Dinge gleichzeitig tun, wobei N die Anzahl der Prozessorkerne ist. Ein Single-Prozessor-Kern kann nur eine Sache gleichzeitig tun. Wie WhozCraig in seinem Kommentar sagte, ist es der Unterschied zwischen tatsächlicher und wahrgenommener Parallelität.

Ja, das kannst du absolut. Vor Ewigkeiten (Win 95?) sind wir von kooperativem Multitasking auf Multithreading umgestiegen, weil immer jemand den kooperativen Teil vermasselt hat. Jedes Programm auf Ihrem Computer hat mindestens einen Thread. Möglicherweise mehr. Und die CPU wechselt wie verrückt ein paar Millionen Mal pro Sekunde zwischen all diesen Threads. Wenn keiner von ihnen etwas zu tun hat, kann es sogar sein, dass es einige Zeit stillsteht.

Multicore-Systeme bedeuten nur, dass zwei oder mehr dieser Threads parallel laufen können.

Allerdings bringt es Ihnen viel weniger, dies zu tun. Alles, was Sie mit Multithreading auf einem Single-Core-Computer tun können, ist Multitasking zu simulieren.

Multitasking reicht aus, um zu verhindern, dass der GUI-Thread aufgrund einer lang andauernden Operation blockiert. Es ist jedoch im Allgemeinen kompliziert zu implementieren, es sei denn, Sie haben Hilfe vom Compiler oder der Sprache (wie C # async … warten). Infolgedessen verwendeten viele GUI-Programmierer nur Multithreading und Invoking, um Multitasking vorzutäuschen. Ob dieser Code auf einem oder mehreren Kernen läuft, spielt keine Rolle.

Am wichtigsten ist, dass Multitasking NICHT für CPU-gebundene Operationen geeignet ist. Aber 95 % aller Async-Probleme sind nicht CPU-gebunden. Sie sind netzwerk- oder festplattengebunden. Auf einem Singlecore-Computer hilft Multithreading auch nicht bei CPU-gebundenen Dingen. Wenn Sie zwei Threads haben, die beide 100 % CPU-Zeit benötigen (dasselbe Programm oder ein anderes), aber nur einen Kern, um sie auszuführen, muss die CPU nur zwischen der Ausführung beider mit 49 % wechseln und die verbleibenden 2 % für all diese verwenden andere Threads, die nur ein bisschen tun.

Schließlich können nur sehr wenige Probleme tatsächlich Multithreaded werden. Versuchen Sie einfach, die Fibonacci-Folge zu multithreaden (ein Thread für jedes Paar), ohne sie langsamer, speicherintensiver und komplexer zu machen.

tl;dr; Sie benötigen Multithreading und einen Multicore-Computer für CPU-gebundene Probleme. Die meisten asynchronen Probleme sind nicht CPU-gebunden. Multitasking reicht völlig aus. Und Sie können mithilfe von Threads vollständig multitasken, sogar auf einem Computer mit einem Kern.

Hier ist ein sehr vereinfachtes Beispiel. Es ist eigentlich ein Prototyp für ein Programm, das ich baue. Es ist eine Implementierung von kooperativem Multitasking in einem einzigen Thread.

main setzt einfach die quit Flag auf false und füllt ein Array von Funktionszeigern (die Aufgaben) und ruft dann auf loop.

loop Verwendet setjmp um einen Rückkehrpunkt für einen nicht-lokalen Sprung zu setzen (ein jump aus der Funktion zurück zu einer vorherigen Position in der Ausführung) und fährt dann fort, die erste Aufgabe (Funktion) aufzurufen.

Jede Aufgabe endet mit yield(). Das heißt, keine der Aufgaben funktioniert tatsächlich return. Sie enthalten nicht nur keine a return; Aussage (was in Ordnung wäre, da sie es sind void Funktionen, dh. Verfahren), aber sie würden die nicht erreichen return auch wenn es da war yield springt zurück zum setjmp Anruf, diesmal mit einer 1 für die if Aussage ein loop. Die Anweisung, die von der gesteuert wird if Anweisung wählt eine andere Aufgabe aus, bevor Sie die erneut eingeben while Schleife.

Jede Task-Funktion wird also mehrmals ausgeführt, was zu dem führt Dispatcher (das if(setjmp... -Anweisung), die eine neue auszuführende Aufgabe auswählt.

#include <stdio.h> 
#include <setjmp.h> 

jmp_buf dispatch; 
int ntasks; 
void (*task[10])(void); 
int quit; 

void yield(void) { 
    longjmp(dispatch, 1); 
} 

void loop() { 
    static int i = 0; 
    if(setjmp(dispatch)) 
        i = (i+1) % ntasks; 
    while(!quit) 
        task[i](); 
} 

int acc = 0; 

void a(void) { 
    if (acc > 10) quit = 1; 
    printf("A\n"); 
    yield(); 
} 
void b(void) { 
    acc *= 2; 
    printf("B\n"); 
    yield(); 
} 
void c(void) { 
    acc += 1; 
    printf("C\n"); 
    yield(); 
} 

int main() { 
    quit = 0; 
    ntasks = 3; 
    task[0] = a; 
    task[1] = b; 
    task[2] = c; 
    loop(); 
    return 0; 
} 

Der Unterschied zwischen diesem Beispiel und einem Einzelprozessor-Multitasking-Computersystem besteht darin, dass der reale Prozessor das Unterbrechen einer Aufgabe mitten in der Ausführung und deren spätere Wiederaufnahme an derselben Stelle unterstützt. Dies ist in einer C-Simulation mit Aufgaben als einzelne Funktionen nicht wirklich möglich. Die Tasks könnten jedoch aus einer Folge von C-Funktionen bestehen, die jeweils an den Dispatcher übergeben werden (vielleicht ein Array von Funktionszeigern oder eine verkettete Liste).

In einem Multithread-Prozess auf einem einzelnen Prozessor kann der Prozessor Ausführungsressourcen zwischen Threads wechseln, was zu einer gleichzeitigen Ausführung führt. Parallelität gibt an, dass mehr als ein Thread Fortschritte macht, die Threads jedoch nicht gleichzeitig ausgeführt werden. Das Umschalten zwischen Threads erfolgt schnell genug, dass die Threads scheinbar gleichzeitig ausgeführt werden.

In demselben Multithread-Prozess in einer Mehrprozessorumgebung mit gemeinsam genutztem Speicher kann jeder Thread im Prozess gleichzeitig auf einem separaten Prozessor ausgeführt werden, was zu einer parallelen Ausführung führt, die eine echte simultane Ausführung ist. Wenn die Anzahl der Threads in einem Prozess kleiner oder gleich der Anzahl der verfügbaren Prozessoren ist, stellt das Thread-Unterstützungssystem des Betriebssystems sicher, dass jeder Thread auf einem anderen Prozessor ausgeführt wird. Beispielsweise kann bei einer Matrixmultiplikation, die mit vier Threads programmiert ist und auf einem System mit zwei Dual-Core-Prozessoren läuft, jeder Software-Thread gleichzeitig auf den vier Prozessorkernen laufen, um gleichzeitig eine Reihe des Ergebnisses zu berechnen.