Twitter und Facebook-Anbindung
X
Tweet Follow @twitterapi
!!! Anbindung an twitter und facebook öffnen !!!

Wenn Ihnen mein Online-Buch gefällt,
dann bedanken Sie sich doch mit einer kleinen Spende...

31.1 Mutexe mit Hilfe der Win API

31.1 Mutexe mit Hilfe der Win API

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
					
#include <windows.h>
#include <stdio.h>
#include "ThreadWrapper.h"

struct SMyThreadData {
	int	iStart;
	int	iEnd;
	int	iID;
	HANDLE	hMutex;
};



// Funktion, welche durch den Thread ausgeführt wird //////////////////////////
DWORD ThreadFunc(CThreadWrapper<SMyThreadData>* pThread) {
	if (pThread->GetData().hMutex != NULL) {
		__try {
			WaitForSingleObject(pThread->GetData().hMutex, INFINITE);

			for (int iCount = pThread->GetData().iStart; iCount < pThread->GetData().iEnd && !pThread->IsTerminated(); iCount++) {
				printf("Thread: %i - %i\n", pThread->GetData().iID, iCount);
				Sleep(100);
			} // end of for
		} __finally {
			ReleaseMutex(pThread->GetData().hMutex);
		} // end of try
	} // end of if

	return 0;
} // ThreadFunc ///////////////////////////////////////////////////////////////



// Hauptfunktion der Anwendung ////////////////////////////////////////////////
int main(int argc, char** argv) {
	HANDLE				hMutex		= CreateMutex(NULL, FALSE, NULL);
	SMyThreadData			sData1		= {0, 10, 1, hMutex};
	SMyThreadData			sData2		= {1000, 1010, 2, hMutex};

	CThreadWrapper<SMyThreadData>*	pThread1	= new CThreadWrapper<SMyThreadData>(&ThreadFunc, sData1);
	CThreadWrapper<SMyThreadData>*	pThread2	= new CThreadWrapper<SMyThreadData>(&ThreadFunc, sData2);

	printf("START\n");

	pThread1->Resume();
	pThread2->Resume();

	// Warten, bis alle Threads fertig sind
	while (!pThread1->IsFinished() || !pThread2->IsFinished()) Sleep(1);

	delete pThread1;
	delete pThread2;

	CloseHandle(hMutex);
	
	printf("ENDE\n");

	return 0;
} // main /////////////////////////////////////////////////////////////////////
					

In den Zeilen 5 bis 10 sehen Sie wieder die Definition der Datenstruktur, welche dem Threadobjekt mit übergeben wird. Hier ist jetzt noch ein Handle für den Mutex hinzu gekommen, da ich für beide Threads den gleichen Mutex verwenden will/muss.

Wie Sie dann in den Zeilen 14 bis 30 sehen können, benutze ich für die Threads meine Templateklasse und benutze die zweite Art der Threadfunktion, welche mein Template erlaubt. Hier ist zum einen eine Bedingung hinzugekommen, welche die Gültigkeit des Handles prüft, sowie das Betreten und Verlassen des kritischen Abschnittes mit Hilfe des Mutex. Das Betreten, in Zeile 18 sollte Ihnen bekannt vorkommen. Ähnlich sah das auch mit den Threads aus, als ich direkt die Win API benutzt hatte. Als dritten Parameter kann man ein Timeout angegeben. Ich habe hier allerdings ein nahezu unendlichen Wert angegeben, was man dem Namen der Konstante entnehmen kann. In der Zeile 25 verlasse ich dann wieder den kritischen Abschnitt mit Hilfe der Funktion "ReleaseMutex".

Ab der Zeile 35 finden Sie jetzt die "main" Funktion. Dort ist jetzt lediglich das Erzeugen des Mutex, seine Freigabe und die Übergabe des Handles an die verwendete Struktur hinzugekommen. Das Anlegen eines Mutex findet in Zeile 36 statt und sollte erklärt werden. Zum einen gibt es die Möglichkeit, dem Mutex einen Namen als dritten Parameter zu verpassen. Ich übergebe hier keinen Namen, aber genau dieser Mechanismus wird dafür benutzt, um das bereits erwähnte mehrfache Starten von Programmen zu verhindern. Belegt man einen Namen, ist der erste Parameter, die Sicherheitsflags, auch ganz interessant. Über jene kann man regeln, ob das Erzeugen des Mutex fehlschlagen soll, falls es den Mutex schon im System gibt, oder ob man den vorhandenen mit nutzen möchte. So könnte man z.B. verhindern, dass zwei Programme etwas in eine Datei schreiben (der Schreibzugriff wird zwar eh durch das Betriebssystem abgefangen, jedoch könnten Ausgaben trotzdem noch gemischt kommen, wenn auch nicht vermischt). Der zweite Parameter gibt lediglich an, ab der kritische Abschnitt schon gesperrt sein soll, was nur in sehr seltenen Fällen von Nöten ist.

Das Freigeben des Mutex läuft wieder genauso wie bei den Threads, wenn man die nativen Win API Funktionen benutzt, nämlich mit der Funktion "CloseHandle".

Zum Seitenanfang
Zum Inhaltsverzeichnis

© Copyright by Thomas Weiß, 2009 - 2012