Maximale Anzahl an Threads pro Prozess?

Hallo zusammen,

gibt es eine maximale Anzahl von Threads, die ein Prozess starten kann oder mache ich hier (s. Code) was falsch?

Gebe ich 64 ein, wartet er bis alle Thread abgearbeitet sind.
Gebe ich 65 ein, dann rauscht er direkt durch (ohne zu warten).

#include <windows.h>
#include <iostream>
#include <vector>

using namespace std;

///////////////////////////////////////////////////////////////////////////////////////////////////

DWORD WINAPI ThreadFunction(LPVOID lpvParameter);

///////////////////////////////////////////////////////////////////////////////////////////////////

int main(int argc, char* argv[])
{
	int intThreadIndex = 0;
	int intThreadCount = 0;
	HANDLE hThread;
	DWORD dwThreadID;
	vector<HANDLE> vhThread;
	vector<DWORD> vdwThreadID;

// number of threads

	cout << "Enter the number of threads: ";
	cin >> intThreadCount;
	if (intThreadCount == 0)
		return 0;

// create threads
	do
	{
		intThreadIndex++;
		hThread = CreateThread(NULL,						// Security informations
								0,							// Size of stack
								ThreadFunction,				// Thread function
								(LPVOID)intThreadIndex,		// 32-bit paramter of the thread function
								0,							// Creation Flags, 0=create now
								&dwThreadID);				// save thread id

		vhThread.push_back(hThread);
		vdwThreadID.push_back(dwThreadID);

		Sleep(50);

	} while (intThreadIndex < intThreadCount);

// wait for threads
	if (intThreadIndex > 0)
	{
		cout << "WaitForMultipleObjects" << endl;
		WaitForMultipleObjects(
			static_cast<DWORD>(vhThread.size()),
			&vhThread[0],
			TRUE,
			INFINITE);

		cout << "CloseHandle" << endl;
		for (intThreadIndex = 0; intThreadIndex<(int)vhThread.size(); ++intThreadIndex)
			CloseHandle(vhThread[intThreadIndex]);
	}

	cout << "Exit program in 3 seconds...";
	Sleep(3000);
	return 0;

}

///////////////////////////////////////////////////////////////////////////////////////////////////

DWORD WINAPI ThreadFunction(LPVOID lpvParameter)
{
	int pintThreadIndex = (int)lpvParameter;

	cout << "Start Thread " << pintThreadIndex << endl;
	Sleep(20000);
	cout << "Quit Thread " << pintThreadIndex << endl;

	return 0;
}

hustbaer

Also 1000 Threads hatte ich schon auf Windows laufen, kein Problem. Es geht auch noch mehr. Das Limit ist - auf 32 Bit Systemen, und wenn man die Stackgrösse nicht verändert - der freie Adressraum. Denn ein Stack hat 1MB und damit gehen sich auf einem 32 Bit System (2GB Usermode Adressraum) halt nur 2048 Threads aus. In Wirklichkeit weniger, da der Code (inklusive sämtliche DLLs) halt auch irgendwo stehen muss.

Aber.

MSDN schrieb:

nCount
[in] Number of object handles in the array pointed to by lpHandles. The maximum number of object handles is MAXIMUM_WAIT_OBJECTS.
lpHandles

Und nu rate mal wie MAXIMUM_WAIT_OBJECTS definiert ist...
Schätze mal das wird 64 sein.

p.S.: das kommt davon wenn man Returncodes nicht auswertet.

p.p.S.: ... und auch keine Doku liest, weil man sich zu gut dafür ist.

Schuldig im Sinne der Anklage.
Danke und eine gute Nacht

Edit: Doku hab ich schon gelesen, aber halt nicht aufmerksam und komplett genug.

Dravere

@Johnson,
Es kommt noch schlimmer, du bist nämlich auch noch im falschen Forum, da dies WinAPI ist und hier nichts zu suchen hat

Aber vielleicht ist es dir eine Lehre, dass du dann beim nächsten Mal die Doku vollständig lesen solltest. Allerdings wäre halt schon nur das prüfen des Rückgabewertes sehr hilfreich gewesen und sowas sollte man halt grundsätzlich immer tun.

Grüssli

hustbaer

Johnson schrieb:

Edit: Doku hab ich schon gelesen, aber halt nicht aufmerksam und komplett genug.

Hihi, OK, dann nehm ich den letzten Teil zurück

EDIT: aber gewöhn dir an, die Doku nochmal etwas ausführlicher zu checken, wenn du ein seltsames (vermutliches) Fehlverhalten beobachtest.

C++ Forumbot

Dieser Thread wurde von Moderator/in Phoemuex aus dem Forum C++ in das Forum WinAPI verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.