Concurrent programming c++?

Question

I keep on hearing about concurrent programing every where. Can you guys throw some light on what it's and how c++ new standards facilitate doing the same?

Solution 1

Concurrency is about your code doing multiple things at the same time. This is typically done with explicit "threads", but there are other possibilities. For example, if you use OpenMP directives in your code then a compiler that supports OpenMP will automatically generate threads for you.

Thread is short for "thread of execution". In a single-threaded C++ program, execution starts at main(), and then proceeds in a sequential fashion. In a multi-threaded program, the first thread starts at main, but additional threads may be started by the application which start at a user-specified function. These then run concurrently, or in parallel with the original thread.

In C++0x threads are started using the std::thread class:

void my_function()
{
    // do stuff
}
std::thread my_thread(my_function); // run my_function in its own thread

The new C++0x standard also supports:

• atomic values and operations with the std::atomic<> class template,
• mutexes for data protection (std::mutex, std::recursive_mutex, etc.)
• lock classes for ease of managing lock lifetime (std::lock_guard<>, std::unique_lock<>)
• std::lock and std::try_lock functions to manage acquiring multiple locks at the same time without risking deadlock
• condition variables to ease waiting for an event (std::condition_variable, std::condition_variable_any)
• futures, promises and packaged tasks to simplify passing data between threads, and waiting for a value to be ready. This addresses the classic "how do I return a value from a thread" question.
• thread-safe initialization of local static objects
• the thread_local keyword to declare thread-local data

I gave a more detailed overview of the new C++0x thread library in my article on devx.com: Simpler Multithreading in C++0x

I write about multithreading and concurrency in C++ on my blog. I'm also writing a book on the topic: C++ Concurrency in Action.

Solution 2

When you say "how c++ new standards facilitate" concurrent programming, I assume you're talking about the soon (?) to be released C++09 standard.

The new standard as it currently stands in draft form supports the following items that help with concurrent programming:

• atomic types and addresses
• a thread class
• thread_local storage (which was just added into the draft standard a few months ago)
• mutual exclusion (mutex classes)
• condition variables - this is particularly nice for Windows, since condition variables are difficult to implement correctly in Win32. This means that eventually Microsoft should provide support for condition variables at least in the MSVC++ runtime, so it will be easy to get correct condition variable semantics on WIn32.

Solution 3

Concurrency is having multiple threads of execution for a given process. As of today, C++ does not directly support it. However, several libraries exist that will tie a given function to a new thread of execution. The Unix standard is the pthreads library.

Solution 4

Perhaps this video might help shine some light for you :-)
http://channel9.msdn.com/posts/Charles/The-Concurrency-Runtime-Fine-Grained-Parallelism-for-C/

Solution 5

C++CSP2 - Easy Concurrency for C++

http://www.cs.kent.ac.uk/projects/ofa/c++csp/

CSP is a based on a proper concurrent paradigm as opposed to threads and locks and all other manner of things which are tacked on as an afterthought.

(See Occam-Pi for a concurrent programming language (also based on CSP))

View more solutions

Comments

[yesraaj]

Articles:Check these articles to know about concurrency 1. Free lunch is over 2. Selected articles by herbsutter 3. Link to pdf

[Nathaniel Sharp]

If Concurrent computing is new to you make sure to check out some basic articles like en.wikipedia.org/wiki/Concurrent_programming.

[Martin York]

The Posix standard (not Unix)

[Martin York]

Has anybody written a good summary about these features yet?

[gbjbaanb]

I think they're heavily based on boost::thread so there shouldn't be much difference between that documentation and the new standard.

[Damian]

Can anything be added now that C++11 is out? I can imagine we can now use move semantics?

[Anthony Williams]

Yes you can use move semantics with std::thread and std::async.

[xyres]

The link you posted returns a 404.

[Martian]

Can someone explain me how there can possibly be 2 controversial answers: yes, C++ is a concurrent language (above), and no, concurrency is another thing (this)? Who is wrong?