(file) Return to Thread.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/Thread.cpp between version 1.27 and 1.54

version 1.27, 2002/09/17 18:01:03 version 1.54, 2003/10/21 18:59:25
Line 44 
Line 44 
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   
 void thread_data::default_delete(void * data) void thread_data::default_delete(void * data)
 { {
    if( data != NULL)    if( data != NULL)
       ::operator delete(data);       ::operator delete(data);
 } }
  
   // l10n start
   void language_delete(void * data)
   {
      if( data != NULL)
      {
         AcceptLanguages * al = static_cast<AcceptLanguages *>(data);
         delete al;
      }
   }
   // l10n end
   
 Boolean Thread::_signals_blocked = false; Boolean Thread::_signals_blocked = false;
   // l10n
   PEGASUS_THREAD_KEY_TYPE Thread::_platform_thread_key = -1;
   Boolean Thread::_key_initialized = false;
   Boolean Thread::_key_error = false;
   
  
 // for non-native implementations // for non-native implementations
 #ifndef PEGASUS_THREAD_CLEANUP_NATIVE #ifndef PEGASUS_THREAD_CLEANUP_NATIVE
Line 115 
Line 132 
  
 #endif #endif
  
   // l10n start
   Sint8 Thread::initializeKey()
   {
      PEG_METHOD_ENTER(TRC_THREAD, "Thread::initializeKey");
      if (!Thread::_key_initialized)
      {
           if (Thread::_key_error)
           {
                   Tracer::trace(TRC_THREAD, Tracer::LEVEL4,
                             "Thread: ERROR - thread key error");
                   return -1;
           }
   
           if (pegasus_key_create(&Thread::_platform_thread_key) == 0)
           {
                   Tracer::trace(TRC_THREAD, Tracer::LEVEL4,
                             "Thread: able to create a thread key");
                   Thread::_key_initialized = true;
           }
           else
           {
                   Tracer::trace(TRC_THREAD, Tracer::LEVEL4,
                             "Thread: ERROR - unable to create a thread key");
                   Thread::_key_error = true;
                   return -1;
           }
      }
   
      PEG_METHOD_EXIT();
      return 0;
   }
   
   Thread * Thread::getCurrent()
   {
       PEG_METHOD_ENTER(TRC_THREAD, "Thread::getCurrent");
       if (Thread::initializeKey() != 0)
       {
           return NULL;
       }
       PEG_METHOD_EXIT();
       return (Thread *)pegasus_get_thread_specific(_platform_thread_key);
   }
   
   void Thread::setCurrent(Thread * thrd)
   {
      PEG_METHOD_ENTER(TRC_THREAD, "Thread::setCurrent");
      if (Thread::initializeKey() == 0)
      {
           if (pegasus_set_thread_specific(Thread::_platform_thread_key,
                                                                    (void *) thrd) == 0)
           {
                   Tracer::trace(TRC_THREAD, Tracer::LEVEL4,
                             "Successful set Thread * into thread specific storage");
           }
           else
           {
                   Tracer::trace(TRC_THREAD, Tracer::LEVEL4,
                             "ERROR: got error setting Thread * into thread specific storage");
           }
      }
      PEG_METHOD_EXIT();
   }
   
   AcceptLanguages * Thread::getLanguages()
   {
       PEG_METHOD_ENTER(TRC_THREAD, "Thread::getLanguages");
   
           Thread * curThrd = Thread::getCurrent();
           if (curThrd == NULL)
                   return NULL;
           AcceptLanguages * acceptLangs =
                    (AcceptLanguages *)curThrd->reference_tsd("acceptLanguages");
           curThrd->dereference_tsd();
       PEG_METHOD_EXIT();
           return acceptLangs;
   }
   
   void Thread::setLanguages(AcceptLanguages *langs) //l10n
   {
      PEG_METHOD_ENTER(TRC_THREAD, "Thread::setLanguages");
   
      Thread * currentThrd = Thread::getCurrent();
      if (currentThrd != NULL)
      {
                   // deletes the old tsd and creates a new one
                   currentThrd->put_tsd("acceptLanguages",
                           language_delete,
                           sizeof(AcceptLanguages *),
                           langs);
      }
   
      PEG_METHOD_EXIT();
   }
   
   void Thread::clearLanguages() //l10n
   {
      PEG_METHOD_ENTER(TRC_THREAD, "Thread::clearLanguages");
   
      Thread * currentThrd = Thread::getCurrent();
      if (currentThrd != NULL)
      {
                   // deletes the old tsd
                   currentThrd->delete_tsd("acceptLanguages");
      }
   
      PEG_METHOD_EXIT();
   }
   // l10n end
   
   
   
   // two special synchronization classes for ThreadPool
   //
   
   class timed_mutex
   {
      public:
         timed_mutex(Mutex* mut, int msec)
            :_mut(mut)
         {
            _mut->timed_lock(msec, pegasus_thread_self());
         }
         ~timed_mutex(void)
         {
            _mut->unlock();
         }
         Mutex* _mut;
   };
   
   
   class try_mutex
   {
      public:
         try_mutex(Mutex* mut)
            :_mut(mut)
         {
            _mut->try_lock(pegasus_thread_self());
         }
         ~try_mutex(void)
         {
            _mut->unlock();
         }
   
         Mutex* _mut;
   };
   
   
 DQueue<ThreadPool> ThreadPool::_pools(true); DQueue<ThreadPool> ThreadPool::_pools(true);
  
  
Line 176 
Line 340 
       _link_pool(_init_thread());       _link_pool(_init_thread());
    }    }
    _pools.insert_last(this);    _pools.insert_last(this);
   
 } }
  
  
   // Note:   <<< Fri Oct 17 09:19:03 2003 mdd >>>
   // the pegasus_yield() calls that preceed each th->join() are to
   // give a thread on the running list a chance to reach a cancellation
   // point before the join
  
 ThreadPool::~ThreadPool(void) ThreadPool::~ThreadPool(void)
 { {
      try
    _pools.remove(this);     {
         // set the dying flag so all thread know the destructor has been entered
         {
            auto_mutex(&(this->_monitor));
    _dying++;    _dying++;
         }
         // remove from the global pools list
         _pools.remove(this);
   
         // start with idle threads.
    Thread *th = 0;    Thread *th = 0;
    th = _pool.remove_first();    th = _pool.remove_first();
         Semaphore* sleep_sem;
   
    while(th != 0)    while(th != 0)
    {    {
       Semaphore *sleep_sem = (Semaphore *)th->reference_tsd("sleep sem");           sleep_sem = (Semaphore *)th->reference_tsd("sleep sem");
   
       if(sleep_sem == 0)       if(sleep_sem == 0)
       {       {
          th->dereference_tsd();          th->dereference_tsd();
          throw NullPointer();          throw NullPointer();
       }       }
  
            // Signal to get the thread out of the work loop.
       sleep_sem->signal();       sleep_sem->signal();
   
            // Signal to get the thread past the end. See the comment
            // "wait to be awakend by the thread pool destructor"
            // Note: the current implementation of Thread for Windows
            // does not implement "pthread" cancelation points so this
            // is needed.
       sleep_sem->signal();       sleep_sem->signal();
       th->dereference_tsd();       th->dereference_tsd();
       // signal the thread's sleep semaphore  
       th->cancel();       th->cancel();
       th->join();       th->join();
       th->empty_tsd();  
       delete th;       delete th;
       th = _pool.remove_first();       th = _pool.remove_first();
    }    }
         th = _dead.remove_first();
    th = _running.remove_first();  
    while(th != 0)    while(th != 0)
    {    {
            sleep_sem = (Semaphore *)th->reference_tsd("sleep sem");
   
            if(sleep_sem == 0)
            {
               th->dereference_tsd();
               throw NullPointer();
            }
   
       // signal the thread's sleep semaphore       // signal the thread's sleep semaphore
            sleep_sem->signal();
            sleep_sem->signal();
            th->dereference_tsd();
       th->cancel();       th->cancel();
       th->join();       th->join();
       th->empty_tsd();  
       delete th;       delete th;
       th = _running.remove_first();           th = _dead.remove_first();
    }    }
  
    th = _dead.remove_first();        {
            th = _running.remove_first();
    while(th != 0)    while(th != 0)
    {    {
       // signal the thread's sleep semaphore       // signal the thread's sleep semaphore
   
               sleep_sem = (Semaphore *)th->reference_tsd("sleep sem");
               if(sleep_sem == 0 )
               {
                  th->dereference_tsd();
                  throw NullPointer();
               }
   
               sleep_sem->signal();
               sleep_sem->signal();
               th->dereference_tsd();
       th->cancel();       th->cancel();
               pegasus_yield();
   
       th->join();       th->join();
       th->empty_tsd();  
       delete th;       delete th;
       th = _dead.remove_first();              th = _running.remove_first();
            }
    }    }
  
 } }
  
      catch(...)
      {
      }
   }
   
 // make this static to the class // make this static to the class
 PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL ThreadPool::_loop(void *parm) PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL ThreadPool::_loop(void *parm)
 { {
Line 244 
Line 453 
       PEG_METHOD_EXIT();       PEG_METHOD_EXIT();
       throw NullPointer();       throw NullPointer();
    }    }
   
   // l10n
      // Set myself into thread specific storage
      // This will allow code to get its own Thread
      Thread::setCurrent(myself);
   
    ThreadPool *pool = (ThreadPool *)myself->get_parm();    ThreadPool *pool = (ThreadPool *)myself->get_parm();
    if(pool == 0 )    if(pool == 0 )
    {    {
       PEG_METHOD_EXIT();       PEG_METHOD_EXIT();
       throw NullPointer();       throw NullPointer();
    }    }
      if(pool->_dying.value())
      {
         PEG_METHOD_EXIT();
         return((PEGASUS_THREAD_RETURN)0);
      }
   
    Semaphore *sleep_sem = 0;    Semaphore *sleep_sem = 0;
    Semaphore *blocking_sem = 0;    Semaphore *blocking_sem = 0;
  
Line 262 
Line 483 
       deadlock_timer = (struct timeval *)myself->reference_tsd("deadlock timer");       deadlock_timer = (struct timeval *)myself->reference_tsd("deadlock timer");
       myself->dereference_tsd();       myself->dereference_tsd();
    }    }
    catch(IPCException &)  
      catch(...)
    {    {
       PEG_METHOD_EXIT();       PEG_METHOD_EXIT();
       myself->exit_self(0);        return((PEGASUS_THREAD_RETURN)0);
    }    }
   
    if(sleep_sem == 0 || deadlock_timer == 0)    if(sleep_sem == 0 || deadlock_timer == 0)
    {    {
       PEG_METHOD_EXIT();       PEG_METHOD_EXIT();
       throw NullPointer();        return((PEGASUS_THREAD_RETURN)0);
      }
   
      while(1)
      {
         try
         {
            if(pool->_dying.value())
               break;
         }
         catch(...)
         {
            return((PEGASUS_THREAD_RETURN)0);
    }    }
  
    while(pool->_dying < 1)        try
    {    {
       sleep_sem->wait();       sleep_sem->wait();
         }
         catch(IPCException& )
         {
            PEG_METHOD_EXIT();
            return((PEGASUS_THREAD_RETURN)0);
         }
  
       // when we awaken we reside on the running queue, not the pool queue       // when we awaken we reside on the running queue, not the pool queue
       if(pool->_dying > 0)        if(pool->_dying.value())
          break;        {
            PEG_METHOD_EXIT();
            return((PEGASUS_THREAD_RETURN)0);
         }
   
  
       PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *_work)(void *) = 0;       PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *_work)(void *) = 0;
       void *parm = 0;       void *parm = 0;
Line 298 
Line 543 
       catch(IPCException &)       catch(IPCException &)
       {       {
          PEG_METHOD_EXIT();          PEG_METHOD_EXIT();
          myself->exit_self(0);           return((PEGASUS_THREAD_RETURN)0);
       }       }
  
       if(_work == 0)       if(_work == 0)
Line 316 
Line 561 
       gettimeofday(deadlock_timer, NULL);       gettimeofday(deadlock_timer, NULL);
       try       try
       {       {
            {
               timed_mutex(&(pool->_monitor), 1000);
               if(pool->_dying.value())
               {
                  _undertaker(parm);
               }
            }
          _work(parm);          _work(parm);
       }       }
       catch(...)       catch(...)
       {       {
          gettimeofday(deadlock_timer, NULL);           return((PEGASUS_THREAD_RETURN)0);
       }       }
   
         // put myself back onto the available list
         try
         {
            timed_mutex(&(pool->_monitor), 1000);
            if(pool->_dying.value() == 0)
            {
       gettimeofday(deadlock_timer, NULL);       gettimeofday(deadlock_timer, NULL);
       if( blocking_sem != 0 )       if( blocking_sem != 0 )
          blocking_sem->signal();          blocking_sem->signal();
  
       // put myself back onto the available list              // If we are not on _running then ~ThreadPool has removed
       try              // us and now "owns" our pointer.
               if( pool->_running.remove((void *)myself) != 0 )
                   pool->_pool.insert_first(myself);
               else
       {       {
          pool->_running.remove((void *)myself);                 return((PEGASUS_THREAD_RETURN)0);
          pool->_link_pool(myself);  
       }       }
       catch(IPCException &)  
            }
            else
            {
               PEG_METHOD_EXIT();
               return((PEGASUS_THREAD_RETURN)0);
            }
         }
         catch(...)
       {       {
          PEG_METHOD_EXIT();          PEG_METHOD_EXIT();
          myself->exit_self(0);           return((PEGASUS_THREAD_RETURN)0);
       }       }
   
    }    }
   
      // TODO: Why is this needed? Why not just continue?
    // wait to be awakend by the thread pool destructor    // wait to be awakend by the thread pool destructor
    sleep_sem->wait();     //sleep_sem->wait();
   
    myself->test_cancel();    myself->test_cancel();
  
    PEG_METHOD_EXIT();    PEG_METHOD_EXIT();
    myself->exit_self(0);  
    return((PEGASUS_THREAD_RETURN)0);    return((PEGASUS_THREAD_RETURN)0);
 } }
  
Line 357 
Line 629 
    PEG_METHOD_ENTER(TRC_THREAD, "ThreadPool::allocate_and_awaken");    PEG_METHOD_ENTER(TRC_THREAD, "ThreadPool::allocate_and_awaken");
    struct timeval start;    struct timeval start;
    gettimeofday(&start, NULL);    gettimeofday(&start, NULL);
      Thread *th = 0;
   
      try
      {
         timed_mutex(&(this->_monitor), 1000);
         if(_dying.value())
         {
            return;
         }
         th = _pool.remove_first();
      }
      catch(...)
      {
         return;
   
      }
  
    Thread *th = _pool.remove_first();  
  
    // wait for the right interval and try again    // wait for the right interval and try again
    while(th == 0 && _dying < 1)     while (th == 0 && _dying.value() < 1)
    {    {
         // will throw an IPCException&
       _check_deadlock(&start) ;       _check_deadlock(&start) ;
  
       if(_max_threads == 0 || _current_threads < _max_threads)       if(_max_threads == 0 || _current_threads < _max_threads)
Line 371 
Line 659 
          continue;          continue;
       }       }
       pegasus_yield();       pegasus_yield();
         try
         {
            timed_mutex(&(this->_monitor), 1000);
            if(_dying.value())
            {
               return;
            }
       th = _pool.remove_first();       th = _pool.remove_first();
    }    }
         catch(...)
         {
            return ;
         }
      }
  
      if(_dying.value() < 1)
    if(_dying < 1)  
    {    {
       // initialize the thread data with the work function and parameters       // initialize the thread data with the work function and parameters
       Tracer::trace(TRC_THREAD, Tracer::LEVEL4,       Tracer::trace(TRC_THREAD, Tracer::LEVEL4,
Line 391 
Line 690 
       th->delete_tsd("blocking sem");       th->delete_tsd("blocking sem");
       if(blocking != 0 )       if(blocking != 0 )
          th->put_tsd("blocking sem", NULL, sizeof(Semaphore *), blocking);          th->put_tsd("blocking sem", NULL, sizeof(Semaphore *), blocking);
         try
         {
            timed_mutex(&(this->_monitor), 1000);
            if(_dying.value())
            {
               th->cancel();
               th->join();
               delete th;
               return;
            }
  
       // put the thread on the running list       // put the thread on the running list
       _running.insert_first(th);  
  
   
            _running.insert_first(th);
       // signal the thread's sleep semaphore to awaken it       // signal the thread's sleep semaphore to awaken it
       Semaphore *sleep_sem = (Semaphore *)th->reference_tsd("sleep sem");       Semaphore *sleep_sem = (Semaphore *)th->reference_tsd("sleep sem");
  
Line 408 
Line 718 
       sleep_sem->signal();       sleep_sem->signal();
       th->dereference_tsd();       th->dereference_tsd();
    }    }
         catch(...)
         {
            PEG_METHOD_EXIT();
            return;
         }
   
      }
    else    else
       _pool.insert_first(th);     {
         th->cancel();
         th->join();
         delete th;
      }
  
    PEG_METHOD_EXIT();    PEG_METHOD_EXIT();
 } }
Line 426 
Line 747 
    Uint32 bodies = 0;    Uint32 bodies = 0;
  
    // first go thread the dead q and clean it up as much as possible    // first go thread the dead q and clean it up as much as possible
    while(_dead.count() > 0)     try
    {    {
         timed_mutex(&(this->_monitor), 1000);
         if(_dying.value() )
         {
            return 0;
         }
   
         while(_dead.count() > 0 && _dying.value() == 0 )
         {
            Tracer::trace(TRC_THREAD, Tracer::LEVEL4, "ThreadPool:: removing and joining dead thread");
       Thread *dead = _dead.remove_first();       Thread *dead = _dead.remove_first();
   
       if(dead == 0)       if(dead == 0)
          throw NullPointer();          throw NullPointer();
       if(dead->_handle.thid != 0)           dead->join();
       {           delete dead;
          dead->detach();  
          destroy_thread(dead->_handle.thid, 0);  
          dead->_handle.thid = 0;  
          while(dead->_cleanup.count() )  
          {  
             // this may throw a permission exception,  
             // which I will remove from the code prior to stabilizing  
             dead->cleanup_pop(true);  
          }          }
       }       }
       delete dead;     catch(...)
       pegasus_sleep(1);     {
    }    }
  
   
    DQueue<Thread> * map[2] =    DQueue<Thread> * map[2] =
       {       {
          &_pool, &_running          &_pool, &_running
Line 457 
Line 781 
    int i = 0;    int i = 0;
    AtomicInt needed(0);    AtomicInt needed(0);
  
 //   for( ; i < 2; i++) << Fri Sep 13 12:49:46 2002 mdd >>  #ifdef PEGASUS_DISABLE_KILLING_HUNG_THREADS
 // This change prevents the thread pool from killing hung threads.     // This change prevents the thread pool from killing "hung" threads.
 // The definition of a hung thread is one that has been on the run queue for too long.     // The definition of a "hung" thread is one that has been on the run queue
 // "too long" is defined as a time interval that is set when the thread pool is created.     // for longer than the time interval set when the thread pool was created.
 // Cancelling "hung" threads has proved to be problematic.     // Cancelling "hung" threads has proven to be problematic.
   
 // With this change the thread pool will not cancel hung threads. This may prevent a     // With this change the thread pool will not cancel "hung" threads.  This
 // crash depending upon the state of the hung thread. It will cause the thread to hang     // may prevent a crash depending upon the state of the "hung" thread.  In
 // around and not do anything besides waste space.     // the case that the thread is actually hung, this change causes the
      // thread resources not to be reclaimed.
 // Idle threads, those that have not executed a routine for a time interval, continue to be  
 // destroyed. This is normal and should not cause any problems.     // Idle threads, those that have not executed a routine for a time
      // interval, continue to be destroyed.  This is normal and should not
      // cause any problems.
    for( ; i < 1; i++)    for( ; i < 1; i++)
   #else
      for( ; i < 2; i++)
   #endif
      {
         try
    {    {
            try_mutex(&(this->_monitor));
         }
         catch(IPCException&)
         {
            return bodies;
         }
   
       q = map[i];       q = map[i];
       if(q->count() > 0 )       if(q->count() > 0 )
       {       {
          try          try
          {          {
               if(_dying.value())
               {
                  return bodies;
               }
   
             q->try_lock();             q->try_lock();
          }          }
          catch(...)          catch(...)
Line 542 
Line 884 
  
                if(th != 0)                if(th != 0)
                {                {
                     if( i == 0 )
                     {
                   th->delete_tsd("work func");                   th->delete_tsd("work func");
                   th->put_tsd("work func", NULL,                   th->put_tsd("work func", NULL,
                               sizeof( PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *)(void *)),                               sizeof( PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *)(void *)),
Line 560 
Line 903 
                      throw NullPointer();                      throw NullPointer();
                   }                   }
  
                   // put the thread on the dead  list  
                   //_dead.insert_first(th);  
                   bodies++;                   bodies++;
                   sleep_sem->signal();  
   
                   th->dereference_tsd();                   th->dereference_tsd();
                        _dead.insert_first(th);
                        sleep_sem->signal();
                   th = 0;                   th = 0;
                }                }
                     else
                     {
                        // deadlocked threads
                        Tracer::trace(TRC_THREAD, Tracer::LEVEL4, "Killing a deadlocked thread");
                        th->cancel();
                        delete th;
                     }
                  }
             }             }
             th = q->next(th);             th = q->next(th);
             pegasus_sleep(1);              pegasus_yield();
          }          }
          q->unlock();          q->unlock();
          while (needed.value() > 0)        }
          {     }
      if(_dying.value() )
         return bodies;
   
      while (needed.value() > 0)   {
             _link_pool(_init_thread());             _link_pool(_init_thread());
             needed--;             needed--;
             pegasus_sleep(0);             pegasus_sleep(0);
          }          }
       }  
    }  
     return bodies;     return bodies;
 } }
  
Line 591 
Line 942 
    if(interval && interval->tv_sec == 0 && interval->tv_usec == 0)    if(interval && interval->tv_sec == 0 && interval->tv_usec == 0)
       return false;       return false;
  
    struct timeval now, finish, remaining;     struct timeval now = {0,0}, finish = {0,0}, remaining = {0,0};
    Uint32 usec;    Uint32 usec;
    gettimeofday(&now, NULL);     pegasus_gettimeofday(&now);
      /* remove valgrind error */
      pegasus_gettimeofday(&remaining);
   
  
    finish.tv_sec = start->tv_sec + interval->tv_sec;    finish.tv_sec = start->tv_sec + interval->tv_sec;
    usec = start->tv_usec + interval->tv_usec;    usec = start->tv_usec + interval->tv_usec;
Line 607 
Line 961 
       return false;       return false;
 } }
  
   
 PEGASUS_THREAD_RETURN ThreadPool::_undertaker( void *parm ) PEGASUS_THREAD_RETURN ThreadPool::_undertaker( void *parm )
 { {
    Thread *myself = reinterpret_cast<Thread *>(parm);     exit_thread((PEGASUS_THREAD_RETURN)1);
    if(myself != 0)     return (PEGASUS_THREAD_RETURN)1;
    {  
       myself->detach();  
       myself->_handle.thid = 0;  
       myself->cancel();  
       delete myself;  
       Thread::test_cancel();  
       Thread::exit_self(0);  
    }  
    return((PEGASUS_THREAD_RETURN)0);  
 } }
  
  
Line 660 
Line 1004 
    th->put_tsd("sleep sem", &_sleep_sem_del, sizeof(Semaphore), (void *)sleep_sem);    th->put_tsd("sleep sem", &_sleep_sem_del, sizeof(Semaphore), (void *)sleep_sem);
  
    struct timeval *dldt = (struct timeval *) ::operator new(sizeof(struct timeval));    struct timeval *dldt = (struct timeval *) ::operator new(sizeof(struct timeval));
      pegasus_gettimeofday(dldt);
   
    th->put_tsd("deadlock timer", thread_data::default_delete, sizeof(struct timeval), (void *)dldt);    th->put_tsd("deadlock timer", thread_data::default_delete, sizeof(struct timeval), (void *)dldt);
    // thread will enter _loop(void *) and sleep on sleep_sem until we signal it    // thread will enter _loop(void *) and sleep on sleep_sem until we signal it
   
    th->run();    th->run();
    _current_threads++;    _current_threads++;
    pegasus_yield();    pegasus_yield();
Line 673 
Line 1020 
 { {
    if(th == 0)    if(th == 0)
       throw NullPointer();       throw NullPointer();
    _pool.insert_first(th);     try
      {
   
         timed_mutex(&(this->_monitor), 1000);
         if(_dying.value())
         {
            th->cancel();
            th->join();
            delete th;
 } }
  
         _pool.insert_first(th);
   
      }
      catch(...)
      {
      }
   }
  
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.27  
changed lines
  Added in v.1.54
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2