sin palabras :)
creo q tendría que evaluar la opción de estudiar relaciones publicas.
jajajaj
(o dormir mas! y no preguntar bol....)
mil graciassss!
y mil perdones por las molestias.
Sebastian.
El día 22/06/07, juanii <[EMAIL PROTECTED]> escribió:
En el main llamas a sleep() (no a Thread::sleep()) y la primera toma
como parametro la cantidad de segundos a dormir (no milisegundos),
main va a tardar 50 minutos en volver de la llamada. Y no, no se va
gastando de a poquito, independientemente de la carga del procesador,
la llamada vuelve en el tiempo especificado.
Saludos!
On 6/22/07, Sebastian Durandeu <[EMAIL PROTECTED]> wrote:
> 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
>
>
--
juanii
_______________________________________________
Lista de correo Programacion.
[email protected]
http://listas.fi.uba.ar/mailman/listinfo/programacion
_______________________________________________
Lista de correo Programacion.
[email protected]
http://listas.fi.uba.ar/mailman/listinfo/programacion
