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

void MultipleWriteTest(Thread& aCurrentThread, TUint aRPriority, TUint aW0Priority, TUint aW1Priority)
{
    const TUint writer0Iters = 300;
    const TUint writer1Iters = 500;
    FifoTest q(32);
    Writer0 writer0(q, aCurrentThread,  writer0Iters);
    Functor fWriter0 = MakeFunctor(writer0, &Writer0::Run);
    Writer1 writer1(q, aCurrentThread, writer1Iters);
    Functor fWriter1 = MakeFunctor(writer1, &Writer1::Run);
    Reader reader(q, aCurrentThread, writer0Iters + writer1Iters);
    Functor fReader = MakeFunctor(reader, &Reader::Run);

    ThreadFunctor* tReader0 = new ThreadFunctor("TSTA", fReader, aRPriority);
    ThreadFunctor* tWriter0 = new ThreadFunctor("TSTB", fWriter0, aW0Priority);
    ThreadFunctor* tWriter1 = new ThreadFunctor("TSTC", fWriter1, aW1Priority);
    tReader0->Start();
    tWriter0->Start();
    tWriter1->Start();

    aCurrentThread.Wait();
    aCurrentThread.Wait();
    aCurrentThread.Wait();

    // The worker threads should be ready to remove.
    delete tReader0;
    delete tWriter0;
    delete tWriter1;
}

void MutexTutorial()
{
	/// .`Mutex`
	
	/// Mutex ("mutual exclusion") is a well known concept in multithreaded programming: When
	/// multiple threads write and read the same data, the access has to be serialized using
	/// Mutex. Following invalid code demonstrates why:
	
	Thread t;
	
	int sum = 0;
	t.Run([&sum] {
		for(int i = 0; i < 1000000; i++)
			sum++;
	});
	
	for(int i = 0; i < 1000000; i++)
		sum++;
	
	t.Wait();
	DUMP(sum);
	
	/// While the expected value is 2000000, produced value is different. The problem is that
	/// both thread read / modify / write `sum` value without any locking. Using `Mutex` locks
	/// the `sum` and thus serializes access to it - read / modify / write sequence  is now
	/// exclusive for the thread that has `Mutex` locked, this fixing the issue. `Mutex` can be
	/// locked / unlocked with `Enter` / `Leave` methods. Alternatively, `Mutex::Lock` helper
	/// class locks `Mutex` in constructor and unlocks it in destructor:
	
	Mutex m;
	sum = 0;
	t.Run([&sum, &m] {
		for(int i = 0; i < 1000000; i++) {
			m.Enter();
			sum++;
			m.Leave();
		}
	});
	
	for(int i = 0; i < 1000000; i++) {
		Mutex::Lock __(m); // Lock m till the end of scope
		sum++;
	}
	
	t.Wait();
	DUMP(sum);
	
	///
}

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

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

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

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