1.C++11 Multi-threading

<atomic> Atomic (header)
<thread> Thread (header)
<mutex> Mutex (header)
<condition_variable> Condition variable (header)
<future> Future (header)

2.<thread>

A thread of execution is a sequence of instructions that can be executed concurrently with other such sequences in multithreading environments, while sharing a same address space.

An initialized thread object represents an active thread of execution; Such a thread object is joinable and has a unique thread id.

A default-constructed (non-initialized) thread object is not joinable, and its thread id is common for all non-joinable threads.

A joinable thread becomes not joinable if moved from, or if either join or detach are called on them.

http://www.cplusplus.com/reference/thread/

3.<atomic>

Atomic types are types that encapsulate a value whose access is guaranteed to not cause data races and can be used to synchronize memory accesses among different threads.

This header declares two C++ classes, atomic and atomic_flag, that implement all the features of atomic types in self-contained classes. The header also declares an entire

set of C-style types and functions compatible with the atomic support in C.
http://www.cplusplus.com/reference/atomic/

4.<mutex>

Header with facilities that allow mutual exclusion (mutex) of concurrent execution of critical sections of code, allowing to explicitly avoid data races.

It contains mutex types, lock types, and specific functions:

Mutex types are lockable types used to protect access to a critical section of code: locking a mutex prevents other threads from locking it (exclusive access) until it is unlocked: mutex, recursive_mutex, timed_mutex, recursive_timed_mutex.
Locks are objects that manage a mutex by associating its access to their own lifetime: lock_guard, unique_lock.
Functions to lock multiple mutexes simultaneously (try_lock, lock) and to directly prevent concurrent execution of a specific function (call_once).
http://www.cplusplus.com/reference/mutex/

5.<condition_variable>

A condition variable is an object able to block the calling thread until notified to resume.

It uses a unique_lock (over a mutex) to lock the thread when one of its wait functions is called. The thread remains blocked until woken up by another thread that calls a notification function on the same condition_variable object.

Objects of type condition_variable always use unique_lock<mutex> to wait: for an alternative that works with any kind of lockable type, see condition_variable_any
http://www.cplusplus.com/reference/condition_variable/

6.<future>

Header with facilities that allow asynchronous access to values set by specific providers, possibly in a different thread.

Each of these providers (which are either promise or packaged_task objects, or calls to async) share access to a shared state with a future object: the point where the provider makes the shared state ready is synchronized with the point the future object accesses the shared state.
http://www.cplusplus.com/reference/future/
https://stackoverflow.com/questions/11004273/what-is-stdpromise