[C++] Thread Pool

[franzxx]

Salve a tutti ancora,
Ho un problema che avevo già citato nell'ultimo mio Post, lo ripropongo qui in modo più chiaro sperando che qualcuno possa aiutarmi.
Ho bisogno di scrivere sostanzialmente una specia di server web multithreading. Devo implementare in C++ un processo che stia in ascolto di eventuali richieste provenienti da altri processi e qualora arrivi una richiesta istanzi un nuovo thread che faccia quello che deve fare......
Il mio problema è: come si implementa in C++ un Pool di Thread dinamico? Sapete dove trovare qualche esempio?????

Aggiungo 2 righe per spiegare (bozza di file main.cpp)

//#include<.....>
//..........

void *threadfunction(void* p);
int main(...)
{
pthread t;
int threadint;

while(true){
//Aspetto una richiesta.....
threadint=pthread_create(&t,NULL,threadfunction,NU LL);
}
}



void *threadfunction(void* p)
{
//codice per fare qualcosa ..........

};



Il mio problema è che il main si blocca finchè non arriva una nuova richiesta, appena arrivata istanzia un thread associato alla variabile t e si rimette in attesa.
Se arriva una nuova richiesta prima che il thread sia finito
il main cercherà di creare un nuovo thread associato alla stessa variabile t,......non va bene.
Vorrei usare un array del tipo:
pthread[] t;

ma non sò bene come scrivere un main che allochi dinamicamente nuovi thread associandoli a variabili t[x] in cui x rappresenta un thread ormai finito......
Aiuto???????!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1
Spero di essere stato chiaro.

Grazie

[oregon]

Lavori con Linux/Windows?

Quale compilatore usi?

[franzxx]

Ciao, grazie della risposta, io lavoro con Linux, però, facendo delle prove ho scoperto che in reltà non importa crearsi un Pool di thread come pensavo, o meglio posso chiamare più volte:

threadint=pthread_create(&t,NULL,threadfunction,NU LL);


senza che il thread sia terminato: non vi sono errori di runtime e tutto sembra andare......
Per essere + chiaro, questo codice funziona:


#include <pthread.h>
#include <iostream>
#include <stdio.h>
void *threadfunction (void* p);
int main(int argc, char **argcv)
{
pthread_t t;
int inth1 = 0;
char* p1="stringa 1";
char* p2 = "stringa 2";


inth1 = pthread_create(&t, NULL,threadfunction,(void*)p1);
inth1 = pthread_create(&t, NULL,threadfunction,(void*)p2);

while (true){
std::cout<<"Main execution"<<'\n';
}
};
void *threadfunction (void* p)
{
char* a = (char*) p;
while (true)
std::cout << "Thread execution : " << a << '\n';

};
//-------------------------------------------------
//(g++ ......... -lpthread) x compilare
//---------------------------------------------------





I due threads vengono istanziati 'sulla stessa variabile t' e tutto funziona, non sono molto esperto di multithreading comunque non capisco a cosa serva allora la variabile t che viene passata alla pthread_create.
In realtà quindio non ho bisogno di nessun thread pool???????
Sembra di no!!
Spero che qualcuno aggiunga note o considerazioni..

Ciao

[oregon]

Il riferimento al thread (che devi trattare come entita' autonoma) e' restituito nel primo parametro.

Per avere un controllo del thread e' necessario che questi riferimenti siano univoci. Se usi sempre una variabile (t) perderai il riferimento ai thread gia' avviati.

Attenzione ... il thread gira comunque (perche' non dovrebbe?) ma se tu volessi controllarlo (che so, assegnare una quantita' di stack diversa ... o altro) avresti bisogno del threadid restituito in quella variabile e tu non potresti farlo.