Ich frage mich, warum dieser Code manchmal einen Deadlock erzeugt (Der Prozess bleibt dann im Process Explorer sichtbar, er hat aber 0 Threads...)?

void* closeEvent = CreateEvent(0, true, false, 0);

unsigned long __stdcall Thread1(void* param)
{
	SetEvent(closeEvent);
	return 0;
}

unsigned long __stdcall Thread2(void* param)
{
	SetEvent(closeEvent);
	return 0;
}

int main()
{
	void* threadHandle1 = CreateThread(0, 0, static_cast<PTHREAD_START_ROUTINE>(Thread1), 0, 0, 0);
	void* threadHandle2 = CreateThread(0, 0, static_cast<PTHREAD_START_ROUTINE>(Thread2), 0, 0, 0);

	WaitForSingleObject(closeEvent, INFINITE);

	TerminateThread(threadHandle1, 0);
	TerminateThread(threadHandle2, 0);
	CloseHandle(threadHandle1);
	CloseHandle(threadHandle2);
}

MSDN "If the target thread is executing certain kernel32 calls when it is terminated, the kernel32 state for the thread's process could be inconsistent"

Dazu gleich noch eine Frage:
Der Code oben ist ein Minimalbeispiel. In meinem Programm macht ein Thread einen blocking call. Dann MUSS ich doch aber TerminateThread() aufrufen um das Programm zu beenden, oder?

(Komischerweise beendet das Minimalbeispiel oben auch wenn ich in Thread 1 eine Endlosschleife einbaue und die TerminateThread()- Aufrufe weglasse. Aber warum?)

Dem ist aber anscheinend nicht so, ist das 100% sicher? Werden alle Threads automatisch beendet, sobald die Main- Funktion zurückkehrt?

Okay, aber ich hatte in Erinnerung dass ein Prozess bestehen bleibt bis der aller letzte Thread beendet wurde...

Dem ist aber anscheinend nicht so, ist das 100% sicher? Werden alle Threads automatisch beendet, sobald die Main- Funktion zurückkehrt?

Ein Prozess belibt wirklich so lange bestehen bis der letzte Thread termniert.
Das Problem ist, dass dr CRT bei verlassen der main Funktion exit aufruft, und dies Funktion ruft ExitProcess auf, und das beendet den Prozess und damit alles Threads.

Doch bitte sagt mir eins, es wird mir einfach nicht klar:

unsigned long __stdcall Thread1(void* param)
{
	// Hier eine nicht wegoptimierte Endlosschleife

	return 0;
}

unsigned long __stdcall Thread2(void* param)
{
	// Hier einen Blocking Call, zB. ReadFile aus einer Pipe

	return 0;
}

int main()
{
	void* threadHandle1 = CreateThread(0, 0, static_cast<PTHREAD_START_ROUTINE>(Thread1), 0, 0, 0);
	void* threadHandle2 = CreateThread(0, 0, static_cast<PTHREAD_START_ROUTINE>(Thread2), 0, 0, 0);
}

Wenn nur thread 1 gestartet wird, beendet sich der Prozess.
Wenn nur thread 2 gestartet wird, beendet sich der Prozess nicht!

Wo ist da der Unterschied, Endlosschleife und Blocking Call?

Der Thread mit dem blocking call blockiert aber...
Der Prozess bleibt sichtbar, mit 0 Threads...

Ich habe Deine Kommentare nicht gelesen.
Dadurch das Du in main returnierst wird ExitProcess aufgerufen, das beendet alle laufenden Threads!
Hättest Du ExitThread am Ende der main Funktion verwendet, hätten die anderen Threads Deinen Prozess am Leben erhalten.

Drücke ich mich so unklar aus?

Der Prozess wird beendet, wenn *alle* Threads beendet sind, oder ExitProcess/TerminateProcess aufgerufen wird (direkt oder z.B. indirekt über Ctrl-C bei Consolen-Programme) oder der Rechner runtergefahren wird.

Grundsätzlich: So beendet man kein Programm, wenn noch andere eigene Threads laufen, die Systemressourcen nutzen! :xmas1:

1. Der Prozess bleibt dann im Process Explorer sichtbar, er hat aber 0 Threads
2. Komischerweise beendet das Minimalbeispiel oben auch wenn ich in Thread 1 eine Endlosschleife einbaue und die TerminateThread()- Aufrufe weglasse. Aber warum?)

Meine Antwort war auf die 2. Frage bezogen...

Die 1. Frage hat er sich ja schon selber beantwortet, oder?

MSDN "If the target thread is executing certain kernel32 calls when it is terminated, the kernel32 state for the thread's process could be inconsistent"