Extensions for concurrency

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Technical Specifications

 

Technical specifications

Filesystem library (filesystem TS)

Library fundamentals (library fundamentals TS)

Library fundamentals 2 (library fundamentals 2 TS)

Extensions for parallelism (parallelism TS)

Concepts (concepts TS)

Extensions for concurrency (concurrency TS)

 

Extensions for concurrency

std::future extensions

future::future

shared_future::shared_future

future::then

shared_future::then

experimental::when_all

experimental::when_any

future::is_ready

shared_future::is_ready

experimental::make_ready_future

experimental::make_exceptional_future

Latches and barriers

experimental::latch

experimental::barrier

experimental::flex_barrier

Atomic smart pointers

experimental::atomic_shared_ptr

experimental::atomic_weak_ptr

 

The C++ Extensions for Concurrency, ISO/IEC TS 19571:xxxx, defines the following new components for the C++ standard library:

Continuations and other extensions for std::future

Defined in header <experimental/future>
Continuations
(constructor) (concurrency TS)	unboxing constructor from future<future<T>> (public member function of std::experimental::future)
then (concurrency TS)	attaches a continuation to a future (public member function of std::experimental::future)
(constructor) (concurrency TS)	unboxing constructor from future<shared_future<T>> (public member function of std::experimental::shared_future)
then (concurrency TS)	attaches a continuation to a shared_future (public member function of std::experimental::shared_future)
Other enhancements
when_all (concurrency TS)	produces a future that becomes ready when all given futures or shared_futures are ready (function template)
when_any (concurrency TS)	produces a future that becomes ready when at least one of the given futures or shared_futures is ready (function template)
is_ready (concurrency TS)	checks if the shared state is ready (public member function of std::experimental::future)
is_ready (concurrency TS)	checks if the shared state is ready (public member function of std::experimental::shared_future)
make_ready_future (concurrency TS)	produces a future that is ready immediately and holds the given value (function template)
make_exceptional_future (concurrency TS)	produces a future that is ready immediately and holds the given exception (function template)

Latches and barriers

Defined in header <experimental/latch>
latch (concurrency TS)	single-use thread barrier (class)
Defined in header <experimental/barrier>
barrier (concurrency TS)	reusable thread barrier (class)
flex_barrier (concurrency TS)	reusable thread barrier with customizable behavior on completion (class)

Atomic smart pointers

These class templates replace the shared_ptr atomic function overloads

Defined in header <experimental/atomic>
atomic_shared_ptr (concurrency TS)	atomic version of std::shared_ptr (class template)
atomic_weak_ptr (concurrency TS)	atomic version of std::weak_ptr (class template)

Feature test macros

Defined in header <experimental/future>
__cpp_lib_experimental_future_continuations	a value of at least 201505 indicates that future::then and other extensions are supported (macro constant)
Defined in header <experimental/latch>
__cpp_lib_experimental_latch	a value of at least 201505 indicates that the latch type is supported (macro constant)
Defined in header <experimental/barrier>
__cpp_lib_experimental_barrier	a value of at least 201505 indicates that barrier type is supported (macro constant)
Defined in header <experimental/atomic>
__cpp_lib_experimental_atomic_smart_pointers	a value of at least 201505 indicates that the atomic smart pointers are supported (macro constant)