Wie mehrere Worker-Threads verwalten?

poncho

Hallo Leute,

ich habe in meinem Programm mehrere Aufgaben zu erledigen. In den Beispielen im Netz wird einfach für jede Aufgabe ein Thread gemacht und fertig. Ich habe sehr viele Aufgaben und will 10 WorkerThreads laufen lassen.
In einem älteren Porgramm für Linux habe ich es so gelöst:

thread_count = 0;   //wieviele Threads momentan laufen
    pthread_t threads[proxylist.size()];

    int i;
    for(i = 0; i < proxylist.size(); i++)
    {
        while(true)
        {
            //neuen Thread starten, wenn Maximum nicht erreicht
            if(thread_count < _NUMTHREADS)
            {
                proxylist[i].id = i;
                pthread_create(&threads[i], NULL, checkProxy, &proxylist[i]);
                break;
            }
            else
            {
                sleep(1);
            }
        }
    }
    // Auf das Ende aller Threads warten
    for(i = 0; i < proxylist.size(); i++)
    {
        pthread_join(threads[i], NULL);
    }

Das hätte ich jetzt bei dem Windows-Programm ähnlich gemacht aber es hängt schon bei

pthread_t threads[proxylist.size()];

bzw. unter Windows

HANDLE hThread[proxylist.size()];

- das funktioniert im Visual Studio nämlich nciht, weil er als Array-Größe eine Konstante haben will.
Ich brauche ja auch eigentlich nur ein Array von der Größe der Thread-Anzahl aber ich weiß ja nicht, welches Element aus dem Array, also welcher Thread, frei geworden ist und mit einem neuen Thread belegt werden kann.

Hat jemand vielleicht einen Tipp, wie man sowas am besten regelt?

CStoll

Ja, nimm einen STL-Container (z.B. vector) dafür:

std::vector<HANDLE> hThread(proxylist.size());

poncho

CStoll schrieb:

Ja, nimm einen STL-Container (z.B. vector) dafür:
std::vector<HANDLE> hThread(proxylist.size());

Stimmt aber gibt es da nicht auch ein Resourcensparendere Methode? Schließlich braucht man ja immer nur so viele Elemente wie maximal Threads vorhanden sind.

Ich hatte jetzt so eine Idee:
Beim Start werden MAXTHREADS gestartet und im ThreadProc kommt am Ende ein PostMessage oder PostThreadMessage an den MainThread. Und beim z.B. WM_USER_THREADEND wird dann für jeden fertigen Thread ein neuer gestartet bis alle Aufgaben durch sind. So könnte ich mir die Thread-Handles sogar ganz sparen.
Was meint der Fachmann dazu?

poncho

Hab es jetzt so gemacht:

// Start
for(plpos = 0; plpos < NUMTHREADS && plpos < proxylist.size(); plpos++)
{
	CreateThread(NULL, 0, ThreadProc, &proxylist.at(plpos), 0, NULL);
}

//Ein Thread ist fertig
case WM_USER_THREADEND:
	if(plpos < proxylist.size())
	{
		CreateThread(NULL, 0, ThreadProc, &proxylist.at(plpos), 0, NULL);
		plpos++;
	}

//ThreadProc
DWORD WINAPI ThreadProc(LPVOID lpParam)
{
	PROXY* proxy = (PROXY*)lpParam;
	//...
	PostMessage(hwndDialog, WM_USER_THREADEND, 0, 0);
	return 0;
}

Und es funktioniert

CStoll

poncho schrieb:

CStoll schrieb:
Ja, nimm einen STL-Container (z.B. vector) dafür:
std::vector<HANDLE> hThread(proxylist.size());
Stimmt aber gibt es da nicht auch ein Resourcensparendere Methode? Schließlich braucht man ja immer nur so viele Elemente wie maximal Threads vorhanden sind.

Klar geht das - du kannst auch mit einem leeren vector beginnen und jedes mal, wenn du einen neuen Thread startest, den zugehörigen HANDLE per push_back() einfügen.