C++ Thread::Join方法代码示例

void test_rwlock(Ardb& db)
{
    WriteTask wtask;
    ReadTask rtask;
    std::map<int, int> mm;
    SpinRWLock lock;
    wtask.lock = &lock;
    wtask.mm = &mm;
    rtask.lock = &lock;
    rtask.mm = &mm;
    Thread* w = new Thread(&wtask);
    std::vector<Thread*> ts;
    for(uint32 i = 0; i < 10; i++)
    {
        Thread* r = new Thread(&rtask);
        r->Start();
        ts.push_back(r);
    }
    w->Start();
    w->Join();
    std::vector<Thread*>::iterator tit = ts.begin();
    while(tit != ts.end())
    {
        (*tit)->Join();
        tit++;
    }
    INFO_LOG("mm size=%u", mm.size());
}

void ovrJobThread::Shutdown()
{
	OVR_ASSERT( Jni == nullptr );	// DetachFromCurrentThread should have been called first
	OVR_ASSERT( MyThread != nullptr );

	MyThread->Join();

	delete MyThread;	// this will call Join()
	MyThread = nullptr;	
}

      /**
       * \brief Test the creation and join of thread. 
       */
      void testThreadCreate()
      {
        void* ret = NULL;
        Callback obj;
        Thread th = Thread(new ThreadArgImpl<Callback>(obj, &Callback::Call, NULL));

        th.Start(false);
        th.Join(&ret);

        CPPUNIT_ASSERT(ret == (void*)0xABCD);
      }

	void Program::Run()
	{
		Thread* th = new Thread(new ThreadStart(DELEGATE_FUNC(Program::target1)));
		Thread* th2 = new Thread(new ThreadStart(DELEGATE_FUNC(Program::target2)));
		Console::WriteLine(new String("Start threads"));
		th->Start();
		th2->Start();
		Thread::Sleep(5000);
		Console::WriteLine(new String("Abort Target 2"));
		th2->Abort();
		Console::WriteLine(new String("Wait for Target 1 to finish (15 iterations)"));
		th->Join();
		Console::WriteLine(new String("Finished"));
	}

void JobManager::Shutdown()
{
	m_running = false;
	while (m_threads.size() > 0) {
		Thread* thread = m_threads.front();
		thread->Join();
		delete thread;

		m_threads.pop_front();
	}

	// finish out finished jobs
	Update();
}

int __stdcall dlltest(int a, int b) noexcept {
	auto f = [](Utf8String s){
		std::printf("thread %u: tls = %s\n", (unsigned)::GetCurrentThreadId(), GetString().GetStr());
		GetString() = std::move(s);
		std::printf("thread %u: tls = %s\n", (unsigned)::GetCurrentThreadId(), GetString().GetStr());
	};

	Thread t;
	t.Create(Bind(f, "world"_u8s), false);
	f("hello"_u8s);
	t.Join();

	return a + b;
}

      /**
       * \brief Test the cancelation of thread. 
       */
      void testThreadCancel()
      {
        void* ret = NULL;
        Callback obj;
        Thread th = Thread(new ThreadArgImpl<Callback>(obj, &Callback::Call2, NULL));

        th.Start(false);
        th.Stop();
        th.Join(&ret);
        
        /* on x86 it returns 0xffffffff
         * on x86-64 0xffffffffffffffff
         * so (void*)-1
         */
        CPPUNIT_ASSERT(ret == (void*)-1);
      }

int main(){
	signal(SIGHUP, HTTPServer::HUP_received);

	Config* con = Config::Instance();
	con->saveParam();
	int Port = atoi(con->lookupParam("Port").c_str());
	cerr << "opening a socket" << endl;
	Socket* masterSocket = new Socket();
	if (masterSocket->Listen(Port) < 0) { 
		// handle error
		cerr << "Error: the listen function has failed, OS cannot accept new connection" << endl; 
		return -1;
	}

	int LENGTH = 2;
	int count = 0;
	Thread* threads[LENGTH];
	for (int i = 0; i < LENGTH; i++)
		threads[i] = NULL;

	ssbuf* ssbuffer;
	Thread* thread;

	Thread* threadWatch = new Thread();
	threadWatch->Run(new ServWatcher(thread));

	MutexInstance::Instance();

	while ((ssbuffer = new ssbuf())->accept(masterSocket) != 0) {
		cout << (threads[count] == NULL) << endl;
		if (threads[count] == NULL) {
			cout << "created new" << endl;
			threads[count] = new Thread();
		}
		thread = threads[count];
		cout << "Opening new connection:"<<count<<endl;

		thread->Join();
		cout << "Joining"<<endl;
		cout << "Run:"<<thread->Run(new HTTPServer(thread, ssbuffer, masterSocket))<<endl;
		cout << "Running:"<<count<<endl;
		if (count++ > LENGTH-1)
			count = 0;
		if (HTTPServer::server_count <= 0) break;
	}
	return 0;
}

int ThreadPool::CancelAll() {
    int ret = 0;
    ThreadVec::iterator it = threads.end();
    while (it != threads.begin()) {
	it --;
	Thread *t = *it;
	if (t->Cancel() == -1 || t->Join() == -1) {
	    ret = -1;
	    break;
	}

	delete t;
	it = threads.erase(it);
    }
    
    return ret;
}

/**
 * Starts an Interactive simulation session
 * the runtime waits until a user shuts down the simulation
 */
int startInteractiveSimulation(int argc, char**argv, void* data)
{
  int retVal = -1;

  // ppriv - NO_INTERACTIVE_DEPENDENCY - for simpler debugging in Visual Studio
#ifndef NO_INTERACTIVE_DEPENDENCY
  initServiceInterfaceData(argc, argv, data);

  //Create the Control Server Thread
  Thread *threadSimulationControl = createControlThread();
  threadSimulationControl->Join();
  delete threadSimulationControl;

  std::cout << "simulation finished!" << std::endl;
#else
  std::cout << "Interactive Simulation not supported when LEAST_DEPENDENCY is defined!!!" << std::endl;
#endif
  return retVal; //TODO 20100211 pv return value implementation / error handling
}

void ThreadPoolImpl::Destroy()
{
	if (!m_bCreate) {
		return;
	}

	do
	{
		//!should wait dead thread have been deleted.
		unsigned int nThread = 0, nTask = 0;
		this->Statistic(nThread, nTask);
		if (m_nMinThread == nThread && 0 == nTask) {
			break;
		}
		else {
			Thread::Sleep(10);
		}

	} while (1);

	TAutoLock lock(m_mtxThread);
	ThreadIterator itr = m_threads.begin();
	while (itr != m_threads.end())
	{
		//!should wait all thread have been done.
		Thread   *pThread = (*itr);
		Runnable *pWorker = pThread->GetRunnable();
		pWorker->Stop();
		pThread->Join();
		delete pThread;
		(*itr) = 0;
		m_threads.erase(itr);
		itr = m_threads.begin();
	}

	//!now, there should be no task.
	assert(m_tasks.empty());
	m_bCreate = false;
}

int main ()
{
  printf ("Results of mutex_test:\n");

  try
  {
    LogFilter filter ("system.threads.*", &print_log);

    printf ("create mutex\n");

    Mutex mutex_holder;

    mutex = &mutex_holder;

    printf ("lock mutex\n");

    mutex->Lock ();

    printf ("create thread\n");

    Thread thread (&run);

    while (!flag);

    printf ("unlock mutex\n");

    mutex->Unlock ();

    thread.Join ();

    printf ("exit\n");
  }
  catch (std::exception& exception)
  {
    printf ("exception: %s\n", exception.what ());
  }

  return 0;
}

		void JoinThread() {
			WAWO_ASSERT( m_thread != NULL );
			if(m_thread->Joinable()) {
				m_thread->Join();
			}
		}

	/// Join timer thread. Wait till exits.
   void join() { _thread.Join(); }