C++11多线程例子.docx

1、C+11多线程例子ThreadsThestd:threadclass represents a thread of execution and is available in theheader.std:threadcan work with regular functions, lambdas and functors (a class implementing operator(). Moreover it allows you to pass any number of parameters to the thread function.Collapse|Copy Code#includ

2、e void func() / do some work int main() std:thread t(func); t.join(); return 0;In this exampletis a thread object representing the thread under which functionfunc()runs. The call tojoinblocks the calling thread (in this case the main thread) until the joined thread finishes execution. If the thread

3、function returns a value, it is ignored. However, the function can take any number of parameters.Collapse|Copy Codevoid func(int i, double d, const std:string& s) std:cout i , d , s std:endl; int main() std:thread t(func, 1, 12.50, sample); t.join(); return 0;Even though its possible to pass any num

4、ber of parameters to the thread function, all parameters are passed by value. If the function needs to take parameters by reference, the passed arguments must be wrapped in astd:ref or std:creflike in the following example.Collapse|Copy Codevoid func(int& a) a+; int main() int a = 42; std:thread t(f

5、unc, std:ref(a); t.join(); std:cout a std:endl; return 0;The program prints 43, but without wrapping a in astd:refthe output would be 42.Apart from the join method, the thread class provides a couple more operations: swap: exchanges the underlying handles of two thread objects detach: allows a threa

6、d of execution to continue independently of the thread object. Detached threads are no longer joinable (you cannot wait for them).Collapse|Copy Codeint main() std:thread t(funct); t.detach(); return 0;An important thing to note is that if a thread function throws an exception it wont be caught with

7、a regular try-catch block. In other words, this wont work:Collapse|Copy Codetry std:thread t1(func); std:thread t2(func); t1.join(); t2.join();catch(const std:exception& ex) std:cout ex.what() std:endl;To propagate exceptions between threads you could catch them in the thread function and store them

8、 in a place where it can be accessed later.Collapse|Copy Codestd:mutex g_mutex;std:vector g_exceptions;void throw_function() throw std:exception(something wrong happened);void func() try throw_function(); catch(.) std:lock_guard lock(g_mutex); g_exceptions.push_back(std:current_exception(); int main

9、() g_exceptions.clear(); std:thread t(func); t.join(); for(auto& e : g_exceptions) try if(e != nullptr) std:rethrow_exception(e); catch(const std:exception& e) std:cout e.what() std:endl; return 0;For more information about catching and propagating exceptions you can readHandling C+ exceptions throw

10、n from worker thread in the main threadandHow can I propagate exceptions between threads?.Before going further it worth noting that theheader provides some helper functions in namespacestd:this_thread: get_id: returns the id of the current thread yield: tells the scheduler to run other threads and c

11、an be used when you are in a busy waiting state sleep_for: blocks the execution of the current thread for at least the specified period sleep_util: blocks the execution of the current thread until the specified moment of time has been reachedLocksIn the last example I needed to synchronize the acces

12、s to theg_exceptionsvector to make sure only one thread at a time can push a new element. For this I used a mutex and a lock on the mutex. A mutex is a core synchronization primitive and it C+11 it comes in four flavors in theheader. mutex: provides the core functionslock()andunlock()and the non-blo

13、ckingtry_lock()method that returns if the mutex is not available. recursive_mutex: allows multiple acquisitions of the mutex from the same thread. timed_mutex: similar to mutex, but it comes with two more methodstry_lock_for()andtry_lock_until()that try to acquire the mutex for a period of time or u

14、ntil a moment in time is reached. recursive_timed_mutex: is a combination of timed_mutex and recusive_mutex.Here is an example for using astd:mutex(notice the use of theget_id()andsleep_for()helper functions mentioned earlier).Collapse|Copy Code#include #include #include #include std:mutex g_lock; void func() g_lock.lock(); std:cout entered thread std:this_thread:get_id() std:endl; std:this_thread:sleep_for(std:chrono:seconds(rand() % 10); std:cout l