hola! Tengo una clase thread que encapsula la api de phtread. Tengo
problemas para detener un thread.
Yo uso un flag que se chequea en un while en el método principal del thread
así:
class MiThread:public Thread{
public:
void main();
};
void MiThread::main()
{
while(this->running())
{
sleep(1500);
std::cout<<"Corriendo"<<std::endl;
}
std::cout<<"Saliendo de la funcion"<<std::endl;
}
Y la uso en un main asi:
int main(int argc, char* argv[])
{
MiThread mithread;
mithread.run();
sleep(3000);
std::cout<<"Salio del sleep"<<std::endl;
mithread.stop();
return 0;
}
El problema que tengo es que me tarda mucho, pero mucho mas que 3 segundos
en terminar el main. Es como que esta atendiendo todo el tiempo al main de
MiThread y esos 3 segundos de "sleep(3000)" los va "gastando" muy de a
poquito.
Podrá ser?
Alguna idea de como se hace esto bien?
En realidad esto lo uso porque tengo muchos un handlers de comunicacion que
se comunican cada uno a un servidor distinto y piden info cada cierto
tiempo. Y cada otro cierto tiempo mayor otro thread recoje toda la info que
los handlers pidieron.
Gracias! cualquier ayuda es bienvenida!
Perdón por el largo!
Sebastian
Aca va thread:
class Thread
{
private:
bool runing;
pthread_t thread;
// Metodo estatico (funcion plana) que realmente ejecuta el thread
// (tomara el puntero this como argumento siempre).
static void* static_run(void* arg);
// Constructor de copia y operator= ocultos (para prevenir descuidos)
Thread(const Thread&);
Thread& operator=(const Thread&);
protected:
// Metodo virtual puro que deben implementar las subclases
virtual void main() = 0;
public:
/*Constructor*/
Thread(){ this->runing = false; }
/* POST: Lanza el thread*/
virtual void run();
/* POST: Pide al thread que finalice sus tareas lo antes posible
* El thread se setea como no corriendo.
*/
virtual void stop();
/*POST: Indica si el thread está corriendo o no */
virtual bool running() const;
/*POST: Espera a que el thread termine realmente */
virtual void join();
/*POST: Espera que el Thread termine y lo libera */
virtual ~Thread();
/*POST: Duerme el thread actual una cierta cantidad de milisegundos*/
static void sleep(unsigned long msecs);
};
void Thread::run(){
int ok = pthread_create(&this->thread, NULL, Thread::static_run, this);
if(ok == 0) /*Si se pudo crear el thread*/
this->runing = true;
}
/*******************************************************************************/
void* Thread::static_run(void* arg){
Thread* th = static_cast<Thread*>(arg);
th->main();
/*Despues de correr la funcion se setea que el thread no esta
corriendo*/
th->runing = false;
pthread_exit(NULL);
return NULL;
}
/*******************************************************************************/
void Thread::stop(){
if(this->runing)
this->runing = false;
pthread_join(this->thread,NULL);
}
/*******************************************************************************/
void Thread::join(){
if(this->runing)
pthread_join(this->thread,NULL);
this->runing = false;
}
/*******************************************************************************/
bool Thread::running() const{
return this->runing;
}
/*******************************************************************************/
Thread::~Thread(){
/*Si esta corriendo espero que termine*/
if(this->runing)
this->join();
this->runing = false;
}
/*******************************************************************************/
void Thread::sleep(unsigned long msecs){
usleep(msecs*1000);
}
_______________________________________________
Lista de correo Programacion.
[email protected]
http://listas.fi.uba.ar/mailman/listinfo/programacion
