Prevent thread creation if Join has already been called....

third_party/libjingle/files/talk/base/thread.cc

 /*
  * libjingle
  * Copyright 2004--2005, Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without 
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice, 
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 88 matching lines @@
 }
 
 bool ThreadManager::ThreadActive(Thread *thread) {
   CritScope cs(&crit_);
   return(std::find(threads_.begin(), threads_.end(), thread) != threads_.end());
 }
 
 Thread::Thread(SocketServer* ss) : MessageQueue(ss), priority_(PRIORITY_NORMAL) {
   g_thmgr.Add(this);
   started_ = false;
+  stopped_ = false;
   has_sends_ = false;
 }
 
 Thread::~Thread() {
   Stop();
   if (active_)
     Clear(NULL);
   g_thmgr.Remove(this);
 }
 
 #ifdef POSIX
 void Thread::Start() {
   pthread_attr_t attr;
   pthread_attr_init(&attr);
   if (priority_ == PRIORITY_IDLE) {
     struct sched_param param;
     pthread_attr_getschedparam(&attr, &param);
     param.sched_priority = 15;           // +15 = 
     pthread_attr_setschedparam(&attr, &param);
   }
   CritScope cs(&started_crit_);
+  // Make sure Join() hasn't been called yet.
+  if (stopped_)
+    return;
   pthread_create(&thread_, &attr, PreRun, this);
   started_ = true;
 }
 
 void Thread::Join() {
   CritScope cs(&started_crit_);
+  stopped_ = true;
   if (started_) {
     void *pv;
     pthread_join(thread_, &pv);
   }
 }
 #endif
 
 #ifdef WIN32
 
 typedef struct tagTHREADNAME_INFO
@@ skipping 21 matching lines @@
   {
   }
 }
 
 void Thread::Start() {
   DWORD flags = 0;
   if (priority_ != PRIORITY_NORMAL) {
     flags = CREATE_SUSPENDED;
   }
   CritScope cs(&started_crit_);
+  // Make sure Join() hasn't been called yet.
+  if (stopped_)
+    return;
   thread_ = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)PreRun, this, flags, NULL);
   if (thread_) {
     if (priority_ != PRIORITY_NORMAL) {
        if (priority_ == PRIORITY_IDLE) {
          ::SetThreadPriority(thread_, THREAD_PRIORITY_IDLE);
        }
        ::ResumeThread(thread_);
     }
   }
   started_ = true;
 }
 
 void Thread::Join() {
   CritScope cs(&started_crit_);
+  stopped_ = true;
   if (started_) {
     WaitForSingleObject(thread_, INFINITE);
     CloseHandle(thread_);
     started_ = false;
   }
 }
 #endif
 
 void *Thread::PreRun(void *pv) {
   Thread *thread = (Thread *)pv;
@@ skipping 155 matching lines @@
   }
 }
 
 AutoThread::~AutoThread() {
   if (ThreadManager::CurrentThread() == this) {
     ThreadManager::SetCurrent(NULL);
   }
 }
 
 } // namespace talk_base