Also ich versuche (wie viele..) eine Client-Server Verbindung herzustellen.
Geht auch, aber jetzt möchte ich auch mehrere Clients gleichzeitig bedienen.
Ich weis das man das mit Async..zeugs oder mit Select bewerkstelligen kann, aber dies behagt mir nicht besonders, denn meine Datei-Download Funktion verkraftet das Select nicht und von Async hab ich keine Ahnung.

Also: Threads
Nur wenn ich für jeden Client einen Thread erstellen will, muss ich dann 10 mal (wenn ich 10 Clients gleichzeitig bedienen will) das hier schreiben:

unsigned  __stdcall ClientThread7(void* pVoid)
{
// tu was
}

oder gibt es einen Trik wie ich mehrere Threads aufrufen kann die alle das Selbe tun ohne alles so oft zu schreiben wie ich Clients haben kann?

Vielen Dank im Voraus!
MfG Tobias

PS: Ich hoffe mich klar ausgedrückt zu haben...

Du machst eine einzige Thread-Funktion für alle Threads und eine struct mit den Parametern. Der Inhalt der struct ist bei jedem Thread anders.

Konkreter gehts ja wohl kaum; ich bitte um etwas Eigeninitiave.

Ich habe nie gesagt "bitte schreib mir mein Programm ich bin zu faul..."

cd9000 schrieb:

Du machst eine einzige Thread-Funktion für alle Threads und eine struct mit den Parametern. Der Inhalt der struct ist bei jedem Thread anders.

So formuliert kapier ich das

Ich wusste halt nicht (tut mir ja leid )
das wenn ich

_beginthreadex (NULL, 0, &FooThread, NULL, 0, &ThreadID);

mehrmals hintereinander mit der selben Funktion (FooThread) aufrufe "eigenständig" laufene Threads bekomme...

MfG Tobias

Das Beginthread sagt ja nur das ein Thread erstellt werden soll. Und dieser muss ja irgendwo im Code anfangen. Und ob das jedes Mal die selbe Funktion ist, ist vollkommen egal.

Allerdings musst du aufpassen, falls mehrere Threads auf die selben Variablen oder Strukturen zugreifen.
Solange diese nur gelesen werden ist das kein Problem. Sobald aber ein Thread diese Daten verändert, musst du das koordinieren, nicht das zwei Threads gleichzeitig an einer Datenstruktur rumfummeln.

Zu beachten ist auch noch das ein Thread nur solange bestehen bleibt, bis er die angegebene Funktion abgearbeitet hat.

Es gibt aber auch ne zweite Möglichkeit für Threads. Die nenen sich Workerthreads und haben wie ein Windows-Fenster eine Message-Queue. Das heisst sie warten bis sie eine Message bekommen und reagieren dann entsprechend darauf. So wie ein Windows-Fenster eben.

Da musst du dann aber jedem Thread auch eine Message schicken, damit er sich beendet.

PS: Du hättest deine Frage auch etwas konkreter stellen können

Also wenn ich mehrere Threads mit der gleichen Funktion laufen lasse und in dieser funktion globale Variablen verändere können alle threads diese verändern?!
Wie ist da sbei Lokalen Vars.? -> Bekommt dann jeder Thread seine eigenen?! oder "teilen" ich alle threads die selben?

Damit ich auch Quasi unendlich viele Clients bedienen kann, könnte ich doch in die struct vectoren reinklatschen?!

Mfg Tobias

Lokale Variablen hat (nehme ich mal an) jeder Thread seine eigenen.

Exakt!

Jeder Thread hat seine eigenen lokalen Variablen!
Aber vorsicht bei "static" Variablen, auf die hat dann wiederum jeder Thread Zugriff und kann sie verändern!

Zugriffe auf globale Variablen sollte man mit Synchronisations-Funktionen tätigen.
Die MSDN bietet sehr schöne Infos über MSDN: Synchronization Functions.

Ebenso wäre die Lektüre des Buches:
Microsoft Windows Programmierung für Experten | ISBN: 3860636154
anzuraten. Da steht sowas nämlich genauestens beschrieben drin...

und all dies geht mit Threads...nur hab ich bis jetzt noch nicht so wirklich viel Ahnung von Threads

Neben Frage: (ja ich hab wirklich keine ahnung von dem was ich tue *seufz*)
Gibt es eigentlich eine maximal Anzahl von Threads die eine Anwendung haben darf? (Win9X / ME)

MfG ToBias

PS:

flenders schrieb:

Und dann solltest du noch darauf achten, dass du nicht die SingleThread sondern die MultiThread-Versionen der Laufzeitbibliothek linkst

[Bitten nicht falsch verstehen]
Ach ne, echt? :p

Wenn man mal davon ausgeht das die LDT genutzt wird um da TSS-Segmente für die einzelnen Threads zu speichern, dürfte man theoretisch etwas um die 8000 Threads möglich machen können.

Realistisch ist das aber nicht, da jeder Thread auch seinen eigenen Stack braucht und ja auch Prozessorzeit benötigt.

Ein Apache-Webserver hat einige Hundert threads, je noch Auslastung soweit ich das beurteilen kann. Aber ob es sogar in die tausender geht mag ich zu bezweifeln. Aber das sind nur Spekulationen.

Ich denke mal du solltest auf jeden Fall ein Maximum an Threads festlegen, da deine Bandbreite mit sicherheit wohl zu allererst in die Knie gehen wird

#include <windows.h>
#include <process.h>

#include <vector>
using namespace std;

unsigned  __stdcall FooThread(void* Parameter);

static unsigned ThreadID; 

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM);

//[...] WIN MAIN [...]

// ist natürlich da aber ist hier unwichtig also lass ich's weg...

struct ParamStruct {
	char* Param1;
	char* Param2;
};

HANDLE hThread1, hThread2;

LRESULT CALLBACK WndProc (HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{

static vector<ParamStruct> Input(2);

switch (iMsg)
{
	case WM_CREATE:
		Input.at(0).Param1 = "FOOOOO";
		Input.at(0).Param2 = "erster thread!";

		Input.at(1).Param1 = "FOOOOO";
		Input.at(1).Param2 = "zweiter thread!";

		hThread1 = (HANDLE) _beginthreadex(NULL, 0, &FooThread, &Input.at(0), 0, &ThreadID);
		hThread2 = (HANDLE) _beginthreadex(NULL, 0, &FooThread, &Input.at(1), 0, &ThreadID);
		break;

	case WM_DESTROY:
		PostQuitMessage(0);
		break;
}
 return DefWindowProc (hwnd, iMsg, wParam, lParam) ;
}

unsigned  __stdcall FooThread(void* Parameter)
{
	struct ParamStruct* Inp;
	Inp = (struct ParamStruct*) Parameter;

    // nur nen Beispiel...
	MessageBox(NULL, Inp -> Param1, Inp -> Param2, 0);

	return 0;
}

MfG Tobias
ThX!

Huhu?

Bin da totaler Anfänger auf diesem Gebiet, aber sieht doch ganz gut aus, finde
ich !
Was mir noch nicht soch ganz klar ist, wozu sind die beiden Variablen ThreadID, wenn man doch eh für jeden neuen Thread ein Handle bekommt ??

Muss man dann nicht auch noch ExitThread oder sowas aufrufen ??
Denke mal, ich werde morgen abend mal dein Proggie testen, jetzt ertmal bubu !

Bye, J.

Was mir noch nicht soch ganz klar ist, wozu sind die beiden Variablen ThreadID, wenn man doch eh für jeden neuen Thread ein Handle bekommt ??

Man bekommt ja nur bei _beginthreadex nen _gültiges_ Handle steht hier auch in nem Thread weiter unten. (oder Seite 2-3...)

J^oe schrieb:

Muss man dann nicht auch noch ExitThread oder sowas aufrufen ??

Ich hab überall gehört: man solle doch den Thread von alleine auslaufen lassen...
Das heißt für mich eben kein ExitThread() sondern ihn bis ganz durch die Funktion durchlaufen zu lassen und fertig...
Oder sehe ich das falsch?