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

void SuiteStartStop::Test()
{
    Thread* threadA = new TestThread("THDA", 'A');
    Thread* threadB = new TestThread("THDB", 'B');

    TEST( ((Thread&) *threadA) == ((Thread&) *threadA) );
    TEST( ((Thread&) *threadA) != ((Thread&) *threadB) );

    threadA->Start();
    threadB->Start();

    for( TUint i = 0 ; i< 10; ++i) {
        TEST(gTestStack->IsEmpty());
        threadA->Signal();
        // use sleeps to avoid dependency on thread priorities being supported
        Thread::Sleep(kSleepMs);
        TEST(gTestStack->Pop('A'));

        threadB->Signal();
        Thread::Sleep(kSleepMs);
        TEST(gTestStack->Pop('B'));

        threadA->Signal();
        Thread::Sleep(kSleepMs);
        TEST(gTestStack->Pop('A'));
    }
    TEST(gTestStack->IsEmpty());

    delete threadA;
    delete threadB;
}

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());
}

int ThreadPool::CreateThreadPool()
{

    for(int i = 0; i<getMaxThreadsNumber(); i++)
    {
        int rc = 0;
        //init lock
        Thread* th = static_cast< Thread* >(new CommonSocketThread());
        /// used to
        th->setInitLocker(	&m_initThread	);
        th->setLocker(	&m_worksLock	);
        th->setThreadId(i);

        m_initThread.lock();
        rc = th->Start();
        th->getCondition().wait(&m_initThread);
        m_initThread.unlock();

        assert(rc == 0);
        m_threadMap.insert( make_pair(i, th) );



    }

    return 0;
}

void TestThread()
{
    Thread* th = new MainTestThread();
    th->Start();
    th->Wait();
    delete th;
}

bool ThreadPoolImpl::Execute(Runnable *pRunnable)
{
	if (0 == pRunnable || !m_bCreate) {
		return false;
	}

	bool bRet = false;
	if (m_tasks.size() >= m_nMaxPendingTask)
	{
		if (m_threads.size() < m_nMaxThread) {
			Thread *pThread = new Thread(new ThreadPoolImpl::Worker(this, pRunnable));
			if (0 != pThread) {
				TAutoLock lock(m_mtxThread);
				m_threads.push_back(pThread);
				pThread->Start();
				bRet = true;
			}
		}
		else {
			// abandon the task.
			bRet = false;
		}
	}
	else
	{
		TAutoLock lock(m_mtxTasks);
		m_tasks.push_back(pRunnable);
		bRet = true;
	}

	return bRet;
}

void TestTimer(Environment& aEnv)
{
    Thread* th = new TimerTestThread(aEnv);
    th->Start();
    th->Wait();
    delete th;
}

void Window2_Created(Win32Window* window)
{
	glwindow = window;

	worker.Attach(&THREAD_Run);
	worker.Start();
}

void TestNetwork(const std::vector<Brn>& aArgs)
{
    OptionParser parser;
    OptionUint adapter("-i", "--interface", 0, "index of network adapter to use");
    parser.AddOption(&adapter);
    if (!parser.Parse(aArgs) || parser.HelpDisplayed()) {
        return;
    }

    std::vector<NetworkAdapter*>* ifs = Os::NetworkListAdapters(Net::InitialisationParams::ELoopbackUse, "TestNetwork");
    ASSERT(ifs->size() > 0 && adapter.Value() < ifs->size());
    TIpAddress addr = (*ifs)[adapter.Value()]->Address();
    for (TUint i=0; i<ifs->size(); i++) {
        (*ifs)[i]->RemoveRef("TestNetwork");
    }
    delete ifs;
    Endpoint endpt(0, addr);
    Endpoint::AddressBuf buf;
    endpt.AppendAddress(buf);
    Print("Using network interface %s\n\n", buf.Ptr());
    Thread* th = new MainNetworkTestThread(addr);
    th->Start();
    th->Wait();
    delete th;
}

bool ThreadPoolImpl::Create(unsigned int nMinThread, unsigned int nMaxThread, unsigned int nMaxPendingTask)
{
	if (m_bCreate) {	// disallow recreate operation.
		return true;	// discard the recreate parameters (i.e. nMin, nMax, nMax)
	}

	if (0 == nMinThread || nMinThread > nMaxThread) {
		return false;
	}

	m_nMinThread = nMinThread;
	m_nMaxThread = nMaxThread;
	m_nMaxPendingTask = nMaxPendingTask;

	unsigned int i = 0;
	for (; i < m_nMinThread; ++i)
	{
		Thread *pThread = new Thread(new ThreadPoolImpl::Worker(this, 0));
		if (0 == pThread) {
			break;
		}
		TAutoLock lock(m_mtxThread);
		m_threads.push_back(pThread);
		pThread->Start();
	}

	m_bCreate = i > 0 ? true : false;
	return m_bCreate;
}

	int Ardb::FlushAll()
	{
		struct VisitorTask: public RawValueVisitor, public Thread
		{
				Ardb* db;
				VisitorTask(Ardb* adb) :
						db(adb)
				{
				}
				int OnRawKeyValue(const Slice& key, const Slice& value)
				{
					db->RawDel(key);
					return 0;
				}
				void Run()
				{
					db->GetEngine()->BeginBatchWrite();
					db->VisitAllDB(this);
					db->GetEngine()->CommitBatchWrite();
					db->GetEngine()->CompactRange(Slice(), Slice());
					delete this;
				}
		};
		/*
		 * Start a background thread to delete kvs
		 */
		Thread* t = new VisitorTask(this);
		t->Start();
		return 0;
	}

	int Ardb::CompactDB(const DBID& db)
	{
		struct CompactTask: public Thread
		{
				Ardb* adb;
				DBID dbid;
				CompactTask(Ardb* db, DBID id) :
						adb(db), dbid(id)
				{
				}
				void Run()
				{
					KeyObject start(Slice(), KV, dbid);
					KeyObject end(Slice(), KV, dbid + 1);
					Buffer sbuf, ebuf;
					encode_key(sbuf, start);
					encode_key(ebuf, end);
					adb->GetEngine()->CompactRange(sbuf.AsString(), ebuf.AsString());
					delete this;
				}
		};
		/*
		 * Start a background thread to compact kvs
		 */
		Thread* t = new CompactTask(this, db);
		t->Start();
		return 0;
	}

void TestThread()
{
    gTestStack = new TestStack();
    Thread* th = new MainTestThread();
    th->Start();
    th->Wait();
    delete th;
    delete gTestStack;
}

int main(int argc, char **argv)
{
    Thread *thread = new Thread();
    thread->SetThreadType(ThreadTypeIntervalBased, 10);

    TestTask *task = new TestTask();

    thread->AddTask(task);
    thread->Start();
}

bool Mail(NickCore *nc, const Anope::string &subject, const Anope::string &message)
{
	if (!Config->UseMail || !nc || nc->email.empty() || subject.empty() || message.empty())
		return false;

	nc->lastmail = Anope::CurTime;
	Thread *t = new MailThread(nc->display, nc->email, subject, message);
	t->Start();

	return true;
}

		void TcpClient::StartReceiveData(void(*ReceiveFunction) (char*, int))
		{
			__PRIVATE_TCPCLIENT::ReceiveDataParameter* parameter = new (__PRIVATE_TCPCLIENT::ReceiveDataParameter);
			parameter->ReceiveFunction = ReceiveFunction;
			parameter->ConnectionLostFunction = ConnectionLost;
			parameter->Socket = _socket,
				parameter->BufferSize = _bufferSize;

			Thread thread = Thread(__PRIVATE_TCPCLIENT::ReceiveData, parameter);
			thread.Start();
		}