{"id":478,"date":"2017-06-29T08:01:22","date_gmt":"2017-06-29T08:01:22","guid":{"rendered":"http:\/\/imalogic.com\/blog\/?p=478"},"modified":"2018-03-14T09:57:51","modified_gmt":"2018-03-14T09:57:51","slug":"c-multi-threading-support","status":"publish","type":"post","link":"https:\/\/imalogic.com\/blog\/2017\/06\/29\/c-multi-threading-support\/","title":{"rendered":"C++ Multi-threading support"},"content":{"rendered":"

One major new feature in the C++0x standard is multi-threading support. Prior to C++0x, any multi-threading support in your C++ compiler has been provided as an extension to the C++ standard, which has meant that the details of that support varies between compilers and platforms. However, with the new standard, all compilers will have to conform to the same memory model and provide the same facilities for multi-threading (though implementors are still free to provide additional extensions). What does this mean for you? It means you\u2019ll be able to port multi-threaded code between compilers and platforms with much reduced cost. This will also reduce the number of different APIs and syntaxes you\u2019ll have to know when writing for multiple platforms.<\/p>\n

The core of the new thread library is the std::thread class, which manages a thread of execution, so let\u2019s start by looking at that.<\/p>\n

Launching Threads<\/strong>
\nYou start a new thread by constructing an instance of std::thread with a function. This function is then used as the entry point for the new thread, and once that function returns, the thread is finished:<\/p>\n

void do_work(); \nstd::thread t(do_work); \n<\/code><\/p>\n

This is just like the thread-creation APIs we\u2019re all used to\u2014but there\u2019s a crucial difference: This is C++, so we\u2019re not restricted to functions. Just like many of the algorithms in the Standard C++ Library, std::thread will accept an object of a type that implements the function call operator (operator()<\/span>), as well as ordinary functions:<\/p>\n

\nclass do_work \n{ \npublic: \nvoid operator()(); \n};<\/code><\/p>\n

do_work dw; \nstd::thread t(dw);<\/p>\n

It\u2019s important to note that this actually copies the supplied object into the thread. If you really want to use the object you supplied (in which case, you\u2019d better make sure that it doesn\u2019t get destroyed before the thread finishes), you can do so by wrapping it in\u00a0std::ref<\/span>:<\/p>\n

\ndo_work dw; \nstd::thread t(std::ref(dw)); \n<\/code><\/p>\n

Most thread creation APIs allow you to pass a single parameter to your newly created thread, typically a\u00a0long<\/span>\u00a0or a\u00a0void*<\/span>.\u00a0std::thread<\/span>\u00a0allows arguments too, but you can pass any number, of (almost) any type. Yes, you read that right: any number of arguments. The constructor uses C++0x\u2019s new\u00a0variadic template facility<\/a>\u00a0to allow a variable number of arguments like the old \u2026 varargs syntax, but in a type-safe manner.<\/p>\n

You can now pass objects of any copyable type as arguments to the thread function:<\/p>\n

\nvoid do_more_work(int i,std::string s,std::vector<double> v); \nstd::thread \nt(do_more_work,42,\"hello\",std::vector<double>(23,3.141)); \n<\/code><\/p>\n

Just as with the function object itself, the arguments are copied into the thread before the function is invoked, so if you want to pass a reference you need to wrap the argument in\u00a0std::ref<\/span>:<\/p>\n

\nvoid foo(std::string&); \nstd::string s; \nstd::thread t(foo,std::ref(s)); \n<\/code><\/p>\n

OK, that\u2019s enough about launching threads. What about waiting for the thread to finish? The C++ Standard calls that \u201cjoining\u201d with the thread (after the POSIX terminology), and you do that with the\u00a0join()<\/span>\u00a0member function:<\/p>\n

\nvoid do_work(); \nstd::thread t(do_work); \nt.join(); \n<\/code><\/p>\n

If you\u2019re not planning on joining with your thread, just destroy the thread object or call\u00a0detach()<\/span>:<\/p>\n

\nvoid do_work(); \nstd::thread t(do_work); \nt.detach(); \n<\/code><\/p>\n

Now, it\u2019s very well launching all these threads, but if you\u2019re going to share data you\u2019d better protect it. The new C++ Standard Library provides facilities for that, too.<\/p>\n

\u00a0<\/p>\n<\/body>","protected":false},"excerpt":{"rendered":"