 |
JLI Spieleprogrammierung
|
| Vorheriges Thema anzeigen :: Nächstes Thema anzeigen |
| Autor |
Nachricht |
Dragon
Super JLI'ler
Alter: 38
Anmeldedatum: 24.05.2004
Beiträge: 340
Wohnort: Sachsen
Medaillen: Keine
|
 Verfasst am: 04.11.2006, 21:59 Titel: Einstieg in Multithreading |
 |
|
Einstieg in Multithreading
von Sven Burow
Einleitung
Herzlich willkommen in meinem Tutorial über das Erstellen von Programmen mit Threads. Ich möchte ihnen hier einen kleinen Einblick in die Welt von Windowsthreads geben und ihnen zeigen, wie man Threads für seine Win32-Programme nutzen kann.
Was sind Threads und wozu braucht man sie?
Um den ersten Teil der Frage zu beantworten möchte ich Wikipedia zitieren:
| Wikipedia hat Folgendes geschrieben: | | Ein Thread (auch Aktivitätsträger), in der deutschen Literatur vereinzelt auch als Faden bezeichnet, ist in der Informatik ein Ausführungsstrang beziehungsweise eine Ausführungsreihenfolge der Abarbeitung der Software. |
http://de.wikipedia.org/wiki/Thread_%28Informatik%29
Jedes gestartetete Programm besteht mindestens aus einem Thread. Wenn Sie mir das nicht glauben, können Sie gern den Taskmanager starten und sich von allen Prozessen die Threadanzahl anzeigen lassen. Ein Prozess kann aber auch aus mehreren Threads bestehen. Jeder Thread erfüllt bei dem Programm eine bestimmte Teilaufgabe. Zum Beispiel kann ein Thread im Hintergrund die E-Mails abrufen, während man sich bereits empfangene E-Mails in aller Ruhe anschauen kann. Hätte man keine Threads, so müsste man erst alle E-Mails runterladen und könnte erst danach sich diese Anschauen.
Viele neue CPUs haben 2 Prozessorkerne. Ein Thread läuft immer genau auf einem Prozessorkern. Der Thread kann aber vom Betriebssystem auf den anderen Prozessorkern umgelagert werden. Um nun beide Prozessorkerne voll ausnutzen zu können, muss ein Programm über min. 2 Threads verfügen.
Los geht´s
Alles was man braucht um auf die Thread-API von Windows zugreifen zu können, ist die windows.h-Headerdatei einzubinden.
| CPP: | | #include <windows.h> |
Der erste Thread eines Prozesses führt den Code aus der Main aus. Um nun dem Thread zu sagen, welchen Code er ausführen soll, brauchen wir eine Funktion. Diese Funktion bekommt immer einen Zeiger übergeben. Beim erstellen des Threads können sie diesen Zeiger angeben. Diesen können Sie verwenden um Startwerte oder ähnliches zu übergeben. Die Thread-Prozedur hat einen Rückgabewert vom Typ DWORD (unsigned long). Diesen können Sie analog zum Rückgabewert der main verstehen. Sie können sogar mit einer Funktion aus der Thread-API den Rückgabewert eines beendeten Threads abfragen. Für weitere Informationen einfach in der MSDN schauen.
| CPP: | | DWORD WINAPI ThreadProc(LPVOID lpParam) |
Den Thread starten Sie mit Hilfe der Funktion CreateThread. Diese erwartet eine Reihe von zu übergebene Parameter. Der erste Parameter ist ein Zeiger auf eine Variable vom Typ SECURITY_ATTRIUTES. Diesem Parameter übergeben Sie einfach die Konstante NULL. Der zweite Parameter ist um einiges interessanter. Jeder Thread bekommt einen eigenen Stack. Angegeben wird hierbei die Größe des Stacks. Wenn Sie 0 übergeben, wird ein systemspezifischer Standardwert genommen. Einen Zeiger auf die Threadfunktion wird als dritter Parameter übergeben. Dem vierten Parameter können Sie den Wert 0 für sofortiges Starten des Threads oder die Konstante CREATE_SUSPENDED für ein Blockieren des Threads angeben. Sollten Sie einen Thread mit CREATE_SUSPENDED angelegt haben, können Sie ihn mit ResumeThread starten. Als fünften und letzen Parameter muss ein Zeiger auf eine Varialbe vom Typ DWORD für die ID des Threads übergeben werden. Die Funktion gibt bei erfolgreichen erstellen des Threads ein Handle auf den Thread zurück.
| CPP: | HANDLE CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes,
SIZE_T dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
DWORD dwCreationFlags,
LPDWORD lpThreadId
); |
Nachdem ein Thread beendet wurde, muss das Handle geschlossen werden. Dafür gibt es die Funktion CloseHandle.
| CPP: | BOOL CloseHandle(
HANDLE hObject
); |
Manchmal soll ein Thread auch einfach nur warten und nichts machen um zum Beispiel den anderen Threads und Prozessen etwas Zeit zu geben. Die gesuchte Funktion trägt den Namen Sleep. Wie der Name der Funktion sagt, legt sie einen Thread schlafen. Ihr wird die Wartezeit in Millisekunden übergeben. Übergibt man ihr den Wert 0, so wird erst den anderen Threads etwas Zeit gegen und danach sofort weitergemacht.
| CPP: | void Sleep(
DWORD dwMilliseconds
);
|
Beispiel
Hier möchte ich Ihnen ein kleines Beispiel vorführen. Es macht nichts weiter als einen Thread zu starten, welcher dann von 5 bin 0 runterzählt und bei erreichen der 0 den Thread verlässt. Diese kleine Beispiel ist in C geschreiben und verwendet daher printf. Es sollte aber kein Problem sein diesen Quellcode auch für C++ umzustellen.
| CPP: | /* threads_1.c */
#include <stdio.h>
#include <conio.h>
#include <windows.h>
DWORD WINAPI ThreadProc(LPVOID lpParam)
{
int i;
printf("Ich bin ein Thread und werde mich in 5 Sekunden von selbst beenden\n");
for(i=5; i>0; --i)
{
printf("Noch %d Sekunden\n", i);
Sleep(1000);
}
printf("Und Tschuess\n");
}
int main()
{
DWORD threadId;
HANDLE threadHandle;
int i=0;
printf("Ich bin das Hauptprogramm\n");
threadHandle = CreateThread(NULL, 0, ThreadProc, NULL, CREATE_SUSPENDED, &threadId);
printf("Thread mit der ID=%d gestartet\n", threadId);
getch();
CloseHandle(threadHandle);
return 0;
} |
Kritsiche Bereiche
Wenn mehrere Threads laufen ist es meistens unvermeidlich, dass Sie auf die selben Resourcen zugreifen. Passiert das zur gleichen Zeit, kann es sein dass es knallt oder etwas sehr seltsames und unverhofftes passiert. Lassen Sie mich das an einem kleinen Beispiel erklären.
| CPP: | /* threads_2a.c */
#include <stdio.h>
#include <conio.h>
#include <windows.h>
DWORD WINAPI ThreadProc(LPVOID lpParam)
{
int i;
DWORD idThread;
idThread = GetCurrentThreadId();
for(i=0; i<10; ++i)
{
printf("%d: Hallo du wunderschoene Welt!\n", idThread);
Sleep(1000);
}
return 0;
}
int main()
{
DWORD threadId[3], mainThreadId;
HANDLE threadHandle[3];
int i=0;
mainThreadId = GetCurrentThreadId();
printf("%d: Ich bin das Hauptprogramm\n", mainThreadId);
for(i=0; i<3; ++i)
{
threadHandle[i] = CreateThread(NULL, 0, ThreadProc, NULL, 0, &threadId[i]);
printf("Thread mit der ID=%d erstellt\n", threadId[i]);
}
getch();
for(i=0; i<3; ++i)
CloseHandle(threadHandle[i]);
return 0;
}
|
Dieses Programm erstellt drei Threads die jeweils die gleiche Threadfunktion bekommen und daher alle das gleiche machen. Jeder Thread soll 10 mal den Text "Hallo du wunderschoene Welt!" in der Konsole ausgeben. Wann man das Programm nun compiliert und startet bekommt man mit etwas Glück eine sehr seltsame Ausgabe.
Grund für diese seltsame Ausgabe ist der gleichzeitige Zugriff der Threads auf die Konsole.Während der eine Thread gerade ein Wort auf die Konsole ausgeben konnte fängt ein anderer Thread an mit der Ausgabe seines Textes an.
Abhilfe schaffen die sogenannten kritischen Bereiche oder engl. [i]critical sections. Für kritsiche Bereiche stellt uns die Thread-API von Windows ein paar Funktionen zur Verfügung die ich Ihnen nun vorstellen werde.
Zu erst muss ein Objekt für den kritischer Bereich mit InitializeCriticalSection initializiert werden. Diese Funktion erwartet einen Zeiger auf eine Variable vom Typ CRITICAL_SECTION. Die Varialbe können Sie als globale definieren. Alternativ können sie auch den Zeiger als Paramter dem Thread übergeben. Es muss aber gewährleistet sein, dass alle Threads zugriff auf den Zeiger haben.
| CPP: | void InitializeCriticalSection(
LPCRITICAL_SECTION lpCriticalSection
); |
Wichtig: CRITICAL_SECTION ist eine Struktur und wird von Windows verwaltet. Ändern Sie niemals einen Wert der Struktur!
Befindet sich nun ein Thread in einem kritischen Bereich im Programm, so können Sie mit der Funktion EnterCriticalSection den kritschen Bereich betreten. Befindet sich ein Thread in dem kritischen Bereich, so müssen alle anderen Threads die ebenfalls den kritschen Bereich betreten wollen warten. Windows versucht mit den Threads fair umzugehen. Daher kommen alle Threads mal dran. Achtung: Die Reihenfolge ist aber nicht festgelegt.
| CPP: | void EnterCriticalSection(
LPCRITICAL_SECTION lpCriticalSection
); |
Soll der kritische Bereich verlassen werden, so müssen Sie die Funktion LeaveCriticalSection aufrufen. Man sollte niemals vergessen einen kritischen Bereich zu verlassen, denn sonst hängt das Programm in einer Endlosschleife. Ich möchte Sie auch noch hinweisen, nur wirklich kritsche Bereiche zu definieren, die auch wirklich kritisch sind. Zum beispiel Sleep-Anweisungen haben darin nichts zu suchen.
| CPP: | void LeaveCriticalSection(
LPCRITICAL_SECTION lpCriticalSection
); |
Gibt es keinen Thread mehr, der den kritischen Bereich betreten kann, dann muss dieser gelöscht werden. Das kann zum Beispiel bei Programmende erfolgen. Hierfür rufen Sie die Funktion DeleteCriticalSection auf. Bitte beachten Sie, dass es wirklich ausgeschlossen ist, dass ein Thread in diesen kritischen Bereich kommt.
| CPP: | void DeleteCriticalSection(
LPCRITICAL_SECTION lpCriticalSection
); |
Und hier ein Lösungsvorschlag für das Ausgabeproblem.
| CPP: | /* threads_2.c */
#include <stdio.h>
#include <conio.h>
#include <windows.h>
/* Ein globales Objekt für den kritischen Bereich bei der Textausgabe */
CRITICAL_SECTION g_csPrint;
DWORD WINAPI ThreadProc(LPVOID lpParam)
{
int i;
DWORD idThread;
idThread = GetCurrentThreadId();
for(i=0; i<10; ++i)
{
/* den kritische Bereich betreten */
EnterCriticalSection(&g_csPrint);
printf("%d: Hallo du wunderschoene Welt!\n", idThread);
/* den kritischen Bereich verlassen*/
LeaveCriticalSection(&g_csPrint);
Sleep(1000);
}
return 0;
}
int main()
{
DWORD threadId[3], mainThreadId;
HANDLE threadHandle[3];
int i=0;
/* Kritschen Bereich initialisieren */
InitializeCriticalSection(&g_csPrint);
mainThreadId = GetCurrentThreadId();
printf("%d: Ich bin das Hauptprogramm\n", mainThreadId);
for(i=0; i<3; ++i)
{
threadHandle[i] = CreateThread(NULL, 0, ThreadProc, NULL, 0, &threadId[i]);
printf("Thread mit der ID=%d erstellt\n", threadId[i]);
}
getch();
for(i=0; i<3; ++i)
CloseHandle(threadHandle[i]);
/* kritischen Bereich löschen*/
DeleteCriticalSection(&g_csPrint);
return 0;
} |
Schlusswort
Threads können manche Dinge sehr vereinfachen aber auch sehr verkomplizieren. Sollte interesse an eine Fortsetzung oder eine Erweiterung dieses Tutorials bestehen, dann meldet euch einfach. Außerdem könnt ihr noch Fragen, Kommentare und Kritik posten.
_________________
Nur wenn man ein Ziel sieht, kann man es auch treffen.
___________
Mein Leben, Freunde und die Spieleentwicklung
Zuletzt bearbeitet von Dragon am 05.11.2006, 15:42, insgesamt 2-mal bearbeitet |
|
| Nach oben |
|
 |
PeaceKiller
JLI Master
Alter: 35
Anmeldedatum: 28.11.2002
Beiträge: 970
Medaillen: Keine
|
| Verfasst am: 05.11.2006, 00:34 Titel: |
|
|
Das ist ja alles schön und gut, aber was nützen einem Threads, wenn man sie nicht synchronisieren kann? Ich denke eine klitzekleine Einführung in Mutexe etc. wäre ziemlich hilfreich.
_________________
»If the automobile had followed the same development cycle as the computer, a Rolls-Royce would today cost $100, get a million miles per gallon, and explode once a year, killing everyone inside.«
– Robert X. Cringely, InfoWorld magazine |
|
| Nach oben |
|
|
Jonathan_Klein
Living Legend
Alter: 37
Anmeldedatum: 17.02.2003
Beiträge: 3433
Wohnort: Siegerland
Medaillen: Keine
|
| Verfasst am: 05.11.2006, 08:35 Titel: |
|
|
Hm, was meinst du mit synchronisieren? So in der For m würde ich die jetzt benutzen, um z.B. das nächste Level zu laden, wärend das erste noch läuft. Oder um wärend den laden den ladebildschirm immer weiter vortzuführen.
Aber man msste jetzt halt noch Prioritäten festlegen können, und auch so Blöcke definierne können wo ein Thread nicht verlassen werden kann.
Und dann vielleicht noch darauf hinweise, das es schwer ist, wenn 2 Threads die selben Daten benuten, wiel man da sehr leicht durcheinander kommen kann.
_________________
https://jonathank.de/games/ |
|
| Nach oben |
|
|
LordHoto
JLI'ler
Alter: 35
Anmeldedatum: 27.03.2003
Beiträge: 137
Wohnort: Gelnhausen
Medaillen: Keine
|
| Verfasst am: 05.11.2006, 13:40 Titel: |
|
|
| Jonathan_Klein hat Folgendes geschrieben: |
Und dann vielleicht noch darauf hinweise, das es schwer ist, wenn 2 Threads die selben Daten benuten, wiel man da sehr leicht durcheinander kommen kann. |
Genau das meint er mit synchronisieren, dass er die Daten, auf welche mehrere Threads zugreifen, waehrend der zugriffe lockt ueber mutexe z.b.. |
|
| Nach oben |
|
|
Otscho
Super JLI'ler
Alter: 36
Anmeldedatum: 31.08.2006
Beiträge: 338
Wohnort: Gummibären-Gasse
Medaillen: Keine
|
| Verfasst am: 20.11.2006, 19:31 Titel: Re: Einstieg in Multithreading |
|
|
| Dragon hat Folgendes geschrieben: | | . Sollte interesse an eine Fortsetzung oder eine Erweiterung dieses Tutorials bestehen, dann meldet euch einfach. Außerdem könnt ihr noch Fragen, Kommentare und Kritik posten. |
Ich hab das mal ausprobiert und es funktioniert wirklich prima.
Also ich wär schon an einer Fortsetzung interessiert.
Da hät ich allerdings noch ne Frage: Wie kann es passieren, dass ein thread für Andere noch blockierend wirkt, wenn man seine Priorität bereits schon um 2 Schritte herabgesetzt hat? |
|
| Nach oben |
|
|
Fallen
JLI MVP
Alter: 40
Anmeldedatum: 08.03.2003
Beiträge: 2860
Wohnort: Münster
Medaillen: 1 (mehr...)
|
| Verfasst am: 20.11.2006, 20:17 Titel: |
|
|
Die Priorität besagt nur das ein Thread mehr Zeit für seine abarbeitung von den Prozessor bekommt, weiter nichts. Deadlocks oder ähnliches kann daher weiterhin auftreten und sollte daher auch unabhängig der Threadpriorität beachtet werden.
_________________
"I have a Core2Quad at 3.2GHz, 4GB of RAM at 1066 and an Nvidia 8800 GTS 512 on Vista64 and this game runs like ass whereas everything else I own runs like melted butter over a smokin' hot 18 year old catholic schoolgirl's arse." |
|
| Nach oben |
|
|
Dragon
Super JLI'ler
Alter: 38
Anmeldedatum: 24.05.2004
Beiträge: 340
Wohnort: Sachsen
Medaillen: Keine
|
|
| Nach oben |
|
|
David
Super JLI'ler
Alter: 39
Anmeldedatum: 13.10.2005
Beiträge: 315
Medaillen: Keine
|
| Verfasst am: 23.11.2006, 12:55 Titel: |
|
|
| PeaceKiller hat Folgendes geschrieben: | | Das ist ja alles schön und gut, aber was nützen einem Threads, wenn man sie nicht synchronisieren kann? Ich denke eine klitzekleine Einführung in Mutexe etc. wäre ziemlich hilfreich. |
Critical Sections sind doch schon eine Art der Synchronisation!  |
|
| Nach oben |
|
|
PeaceKiller
JLI Master
Alter: 35
Anmeldedatum: 28.11.2002
Beiträge: 970
Medaillen: Keine
|
| Verfasst am: 23.11.2006, 15:17 Titel: |
|
|
| David hat Folgendes geschrieben: | | PeaceKiller hat Folgendes geschrieben: | | Das ist ja alles schön und gut, aber was nützen einem Threads, wenn man sie nicht synchronisieren kann? Ich denke eine klitzekleine Einführung in Mutexe etc. wäre ziemlich hilfreich. |
Critical Sections sind doch schon eine Art der Synchronisation! |
Ich denke, dass das Dragon nachträglich ergänzt hat.
_________________
»If the automobile had followed the same development cycle as the computer, a Rolls-Royce would today cost $100, get a million miles per gallon, and explode once a year, killing everyone inside.«
– Robert X. Cringely, InfoWorld magazine |
|
| Nach oben |
|
|
David
Super JLI'ler
Alter: 39
Anmeldedatum: 13.10.2005
Beiträge: 315
Medaillen: Keine
|
| Verfasst am: 23.11.2006, 17:00 Titel: |
|
|
| Oh, wusst ich nich. Nett wäre allerdings noch etwas über Mutexe, Events und Semaphoren. |
|
| Nach oben |
|
|
Faller
Junior JLI'ler
Alter: 36
Anmeldedatum: 30.11.2006
Beiträge: 88
Wohnort: Dresden
Medaillen: Keine
|
| Verfasst am: 11.09.2007, 14:35 Titel: |
|
|
Ich versuche gerade mit deinem Tutorial theads zu verstehen.
und hab mir einfachs halber mal genau deinen 1 prog übernommen 
hab nur nen return noch reingebaut da es mir sonzt nen Fehler wirft.
Hier mal der code
| CPP: | #include <stdio.h>
#include <conio.h>
#include <windows.h>
DWORD WINAPI ThreadProc(LPVOID lpParam)
{
int i;
printf("Ich bin ein Thread und werde mich in 5 Sekunden von selbst beenden\n");
for(i=5; i>0; --i)
{
printf("Noch %d Sekunden\n", i);
Sleep(1000);
}
printf("Und Tschuess\n");
getch();
return((DWORD)lpParam);
}
int main()
{
DWORD threadId;
HANDLE threadHandle;
int i=0;
printf("Ich bin das Hauptprogramm\n");
threadHandle = CreateThread(NULL, 0, ThreadProc, NULL, CREATE_SUSPENDED, &threadId);
printf("Thread mit der ID=%d gestartet\n", threadId);
getch();
CloseHandle(threadHandle);
return 0;
}
|
ansich genau wie im tutorial.
Problem ist nur das er mir in der konsole meinen Konsolenprojekts nur folgendes ausgibt.
Ich bin das Hauptprogramm
Thread mit der ID=4824 gestartet
Dann wartet er ne eingabe ab und ich kann das prog beeneden
und das ist ja eigentlich net richtig.
also hab ich mich noch mal bei google schlau gemacht und hab folgendes gefunden.
das man unter projekt --> Einstellungen -->c/c++ --> Code Generation --> Multithread angeben muss.
hab ich auch gemacht funktioniert aber immer noch net.
muss ich ihrgentwas noch einstellen in meinem compieler.
Nutze vs 6.0 Autoren version die von der cd aus dem buch
Nun ich hoffe das mir jemand meine fragen beantworten kann.
mfg Faller
_________________
versuche alles nur wann und wie ist die frage |
|
| Nach oben |
|
|
Dragon
Super JLI'ler
Alter: 38
Anmeldedatum: 24.05.2004
Beiträge: 340
Wohnort: Sachsen
Medaillen: Keine
|
| Verfasst am: 20.09.2007, 15:00 Titel: |
|
|
Das Problem ist das getch in deinem Thread. Dein Programm wartet nämlich 2mal auf eine Tastatureingabe.
_________________
Nur wenn man ein Ziel sieht, kann man es auch treffen.
___________
Mein Leben, Freunde und die Spieleentwicklung |
|
| Nach oben |
|
|
newby
JLI'ler
Anmeldedatum: 17.08.2007
Beiträge: 106
Medaillen: Keine
|
| Verfasst am: 31.07.2008, 09:16 Titel: |
|
|
| ich finde das tutorial erstmal richtig klasse hier, hat bei auch fast alles sofort funktioniert. Aber ich hab ein Problem wenn ich die kritische Zone betreten will. Ich habe vier threads die alle eine Ausgabe in der Konsole machen sollen. Deswegen sollen sie vorher in die kritische zone. Das verursacht aber einen laufzeitfehler. Seltsam ist, dass es manchmal ein oder zwei threads schaffen, dann wieder keiner darein zukommen. |
|
| Nach oben |
|
|
newby
JLI'ler
Anmeldedatum: 17.08.2007
Beiträge: 106
Medaillen: Keine
|
| Verfasst am: 23.02.2009, 14:31 Titel: |
|
|
| Ich habe noch eine Frage zu den kritischen Bereichen. Ich habe in einem anderen C++ Buch gelesen, dass ein kritischer Bereich quasi Daten in einem Käfig sind, für die immer nur ein Thread den Schlüssel hat. Jetzt frage ich mich, wie ich definieren kann, welche Daten in die Critical Section gehören und welche nicht. |
|
| Nach oben |
|
|
|
|
Du kannst keine Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum nicht antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.
|
Powered by phpBB © 2001, 2005 phpBB Group
Deutsche Übersetzung von phpBB.de |
FAQ
Suchen
Mitgliederliste
Benutzergruppen
Medaillen
Registrieren
Profil
Einloggen, um private Nachrichten zu lesen
Login
