Table of contents

concurrencpp overview

"Hello world" program using concurrencpp:

#include"concurrencpp/concurrencpp.h"#include<iostream>intmain() {    concurrencpp::runtime runtime;auto result = runtime.thread_executor()->submit([] {        std::cout <<"hello world" << std::endl;    });    result.get();return0;}

Concurrent even-number counting:

#include"concurrencpp/concurrencpp.h"#include<iostream>#include<vector>#include<algorithm>#include<ctime>usingnamespaceconcurrencpp;std::vector<int>make_random_vector() {    std::vector<int>vec(64 *1'024);std::srand(std::time(nullptr));for (auto& i : vec) {        i = ::rand();    }return vec;}result<size_t>count_even(std::shared_ptr<thread_pool_executor> tpe,const std::vector<int>& vector) {constauto vecor_size = vector.size();constauto concurrency_level = tpe->max_concurrency_level();constauto chunk_size = vecor_size / concurrency_level;    std::vector<result<size_t>> chunk_count;for (auto i =0; i < concurrency_level; i++) {constauto chunk_begin = i * chunk_size;constauto chunk_end = chunk_begin + chunk_size;auto result = tpe->submit([&vector, chunk_begin, chunk_end]() ->size_t {returnstd::count_if(vector.begin() + chunk_begin, vector.begin() + chunk_end, [](auto i) {return i %2 ==0;            });        });        chunk_count.emplace_back(std::move(result));    }size_t total_count =0;for (auto& result : chunk_count) {        total_count +=co_await result;    }co_return total_count;}intmain() {    concurrencpp::runtime runtime;constauto vector =make_random_vector();auto result =count_even(runtime.thread_pool_executor(), vector);constauto total_count = result.get();    std::cout <<"there are" << total_count <<" even numbers in the vector" << std::endl;return0;}

Tasks

concurrencpp coroutines

Executors

executor API

classexecutor {/*        Initializes a new executor and gives it a name.*/executor(std::string_view name);/*        Destroys this executor.*/virtual~executor()noexcept =default;/*        The name of the executor, used for logging and debugging.*/const std::string name;/*        Schedules a task to run in this executor.        Throws concurrencpp::errors::runtime_shutdown exception if shutdown was called before.*/virtualvoidenqueue(concurrencpp::task task) = 0;/*        Schedules a range of tasks to run in this executor.        Throws concurrencpp::errors::runtime_shutdown exception if shutdown was called before.*/virtualvoidenqueue(std::span<concurrencpp::task> tasks) = 0;/*        Returns the maximum count of real OS threads this executor supports.        The actual count of threads this executor is running might be smaller than this number.        returns numeric_limits<int>::max if the executor does not have a limit for OS threads.*/virtualintmax_concurrency_level()constnoexcept = 0;/*        Returns true if shutdown was called before, false otherwise.*/virtualboolshutdown_requested()constnoexcept = 0;/*        Shuts down the executor:        - Tells underlying threads to exit their work loop and joins them.        - Destroys unexecuted coroutines.        - Makes subsequent calls to enqueue, post, submit, bulk_post and            bulk_submit to throw concurrencpp::errors::runtime_shutdown exception.        - Makes shutdown_requested return true.*/virtualvoidshutdown()noexcept = 0;/*        Turns a callable and its arguments into a task object and        schedules it to run in this executor using enqueue.        Arguments are passed to the task by decaying them first.        Throws errors::runtime_shutdown exception if shutdown has been called before.*/template<classcallable_type,class ... argument_types>voidpost(callable_type&& callable, argument_types&& ... arguments);/*        Like post, but returns a result object that passes the asynchronous result.        Throws errors::runtime_shutdown exception if shutdown has been called before.*/template<classcallable_type,class ... argument_types>    result<type>submit(callable_type&& callable, argument_types&& ... arguments);/*        Turns an array of callables into an array of tasks and        schedules them to run in this executor using enqueue.        Throws errors::runtime_shutdown exception if shutdown has been called before.*/template<classcallable_type>voidbulk_post(std::span<callable_type> callable_list);/*        Like bulk_post, but returns an array of result objects that passes the asynchronous results.        Throws errors::runtime_shutdown exception if shutdown has been called before.*/template<classcallable_type>    std::vector<concurrencpp::result<type>>bulk_submit(std::span<callable_type> callable_list);};

Executor types

auto result = background_executor.submit([] {/* some blocking action*/ });auto done_result =co_await result.resolve();co_awaitresume_on(some_cpu_executor);auto val =co_await done_result;// runs inside some_cpu_executor

Using executors

thread_pool_executor API

classthread_pool_executor {/*        Returns the number of milliseconds each thread-pool worker        remains idle (lacks any task to execute) before exiting.        This constant can be set by passing a runtime_options object        to the constructor of the runtime class.*/    std::chrono::millisecondsmax_worker_idle_time()constnoexcept;};

manual_executor API

classmanual_executor {/*        Destructor. Equivalent to clear.*/~manual_executor()noexcept;/*        Returns the number of enqueued tasks at the moment of invocation.        This number can change quickly by the time the application handles it, it should be used as a hint.        This method is thread safe.        Might throw std::system_error if one of the underlying synchronization primitives throws.*/size_tsize()constnoexcept;/*        Queries whether the executor is empty from tasks at the moment of invocation.        This value can change quickly by the time the application handles it, it should be used as a hint.        This method is thread safe.        Might throw std::system_error if one of the underlying synchronization primitives throws.*/boolempty()constnoexcept;/*        Clears the executor from any enqueued but yet to-be-executed tasks,        and returns the number of cleared tasks.        Tasks enqueued to this executor by (post_)submit method are resumed        and errors::broken_task exception is thrown inside them.        Ongoing tasks that are being executed by loop_once(_XXX) or loop(_XXX) are uneffected.        This method is thread safe.        Might throw std::system_error if one of the underlying synchronization primitives throws.        Throws errors::shutdown_exception if shutdown was called before.*/size_tclear();/*        Tries to execute a single task. If at the moment of invocation the executor        is empty, the method does nothing.        Returns true if a task was executed, false otherwise.        This method is thread safe.        Might throw std::system_error if one of the underlying synchronization primitives throws.        Throws errors::shutdown_exception if shutdown was called before.*/boolloop_once();/*        Tries to execute a single task.        This method returns when either a task was executed or max_waiting_time        (in milliseconds) has reached.        If max_waiting_time is 0, the method is equivalent to loop_once.        If shutdown is called from another thread, this method returns        and throws errors::shutdown_exception.        This method is thread safe.        Might throw std::system_error if one of the underlying synchronization primitives throws.        Throws errors::shutdown_exception if shutdown was called before.*/boolloop_once_for(std::chrono::milliseconds max_waiting_time);/*        Tries to execute a single task.        This method returns when either a task was executed or timeout_time has reached.        If timeout_time has already expired, this method is equivalent to loop_once.        If shutdown is called from another thread, this method        returns and throws errors::shutdown_exception.        This method is thread safe.        Might throw std::system_error if one of the underlying synchronization primitives throws.        Throws errors::shutdown_exception if shutdown was called before.*/template<classclock_type,classduration_type>boolloop_once_until(std::chrono::time_point<clock_type, duration_type> timeout_time);/*        Tries to execute max_count enqueued tasks and returns the number of tasks that were executed.        This method does not wait: it returns when the executor        becomes empty from tasks or max_count tasks have been executed.        This method is thread safe.        Might throw std::system_error if one of the underlying synchronization primitives throws.        Throws errors::shutdown_exception if shutdown was called before.*/size_tloop(size_t max_count);/*        Tries to execute max_count tasks.        This method returns when either max_count tasks were executed or a        total amount of max_waiting_time has passed.        If max_waiting_time is 0, the method is equivalent to loop.        Returns the actual amount of tasks that were executed.        If shutdown is called from another thread, this method returns        and throws errors::shutdown_exception.        This method is thread safe.        Might throw std::system_error if one of the underlying synchronization primitives throws.        Throws errors::shutdown_exception if shutdown was called before.*/size_tloop_for(size_t max_count, std::chrono::milliseconds max_waiting_time);/*        Tries to execute max_count tasks.        This method returns when either max_count tasks were executed or timeout_time has reached.        If timeout_time has already expired, the method is equivalent to loop.        Returns the actual amount of tasks that were executed.        If shutdown is called from another thread, this method returns        and throws errors::shutdown_exception.        This method is thread safe.        Might throw std::system_error if one of the underlying synchronization primitives throws.        Throws errors::shutdown_exception if shutdown was called before.*/template<classclock_type,classduration_type>size_tloop_until(size_t max_count, std::chrono::time_point<clock_type, duration_type> timeout_time);/*        Waits for at least one task to be available for execution.        This method should be used as a hint,        as other threads (calling loop, for example) might empty the executor,        before this thread has a chance to do something with the newly enqueued tasks.        If shutdown is called from another thread, this method returns        and throws errors::shutdown_exception.        This method is thread safe.        Might throw std::system_error if one of the underlying synchronization primitives throws.        Throws errors::shutdown_exception if shutdown was called before.*/voidwait_for_task();/*        This method returns when one or more tasks are available for        execution or max_waiting_time has passed.        Returns true if at at least one task is available for execution, false otherwise.        This method should be used as a hint, as other threads (calling loop, for example)        might empty the executor, before this thread has a chance to do something        with the newly enqueued tasks.        If shutdown is called from another thread, this method        returns and throws errors::shutdown_exception.        This method is thread safe.        Might throw std::system_error if one of the underlying synchronization primitives throws.        Throws errors::shutdown_exception if shutdown was called before.*/boolwait_for_task_for(std::chrono::milliseconds max_waiting_time);/*        This method returns when one or more tasks are available for execution or timeout_time has reached.        Returns true if at at least one task is available for execution, false otherwise.        This method should be used as a hint,        as other threads (calling loop, for example) might empty the executor,        before this thread has a chance to do something with the newly enqueued tasks.        If shutdown is called from another thread, this method        returns and throws errors::shutdown_exception.        This method is thread safe.        Might throw std::system_error if one of the underlying synchronization primitives throws.        Throws errors::shutdown_exception if shutdown was called before.*/template<classclock_type,classduration_type>boolwait_for_task_until(std::chrono::time_point<clock_type, duration_type> timeout_time);/*        This method returns when max_count or more tasks are available for execution.        This method should be used as a hint, as other threads        (calling loop, for example) might empty the executor,        before this thread has a chance to do something with the newly enqueued tasks.        If shutdown is called from another thread, this method returns        and throws errors::shutdown_exception.        This method is thread safe.        Might throw std::system_error if one of the underlying synchronization primitives throws.        Throws errors::shutdown_exception if shutdown was called before.*/voidwait_for_tasks(size_t max_count);/*        This method returns when max_count or more tasks are available for execution        or max_waiting_time (in milliseconds) has passed.        Returns the number of tasks available for execution when the method returns.        This method should be used as a hint, as other        threads (calling loop, for example) might empty the executor,        before this thread has a chance to do something with the newly enqueued tasks.        If shutdown is called from another thread, this method returns        and throws errors::shutdown_exception.        This method is thread safe.        Might throw std::system_error if one of the underlying synchronization primitives throws.        Throws errors::shutdown_exception if shutdown was called before.*/size_twait_for_tasks_for(size_t count, std::chrono::milliseconds max_waiting_time);/*        This method returns when max_count or more tasks are available for execution        or timeout_time is reached.        Returns the number of tasks available for execution when the method returns.        This method should be used as a hint, as other threads        (calling loop, for example) might empty the executor,        before this thread has a chance to do something with the newly enqueued tasks.        If shutdown is called from another thread, this method returns        and throws errors::shutdown_exception.        This method is thread safe.        Might throw std::system_error if one of the underlying synchronization primitives throws.        Throws errors::shutdown_exception if shutdown was called before.*/template<classclock_type,classduration_type>size_twait_for_tasks_until(size_t count, std::chrono::time_point<clock_type, duration_type> timeout_time);        };

Result objects

result type

result API

classresult{/*        Creates an empty result that isn't associated with any task.*/result()noexcept =default;/*        Destroys the result. Associated tasks are not cancelled.        The destructor does not block waiting for the asynchronous result to become ready.*/~result()noexcept =default;/*        Moves the content of rhs to *this. After this call, rhs is empty.*/result(result&& rhs)noexcept =default;/*        Moves the content of rhs to *this. After this call, rhs is empty. Returns *this.*/    result&operator = (result&& rhs)noexcept =default;/*        Returns true if this is a non-empty result.        Applications must not use this object if this->operator bool() is false.*/explicitoperatorbool()constnoexcept;/*        Queries the status of *this.        The returned value is any of result_status::idle, result_status::value or result_status::exception.        Throws errors::empty_result if *this is empty.*/    result_statusstatus()const;/*        Blocks the current thread of execution until this result is ready,        when status() != result_status::idle.        Throws errors::empty_result if *this is empty.        Might throw std::bad_alloc if fails to allocate memory.        Might throw std::system_error if one of the underlying synchronization primitives throws.*/voidwait();/*        Blocks until this result is ready or duration has passed. Returns the status        of this result after unblocking.        Throws errors::empty_result if *this is empty.        Might throw std::bad_alloc if fails to allocate memory.        Might throw std::system_error if one of the underlying synchronization primitives throws.*/template<classduration_unit,classratio>    result_statuswait_for(std::chrono::duration<duration_unit, ratio> duration);/*        Blocks until this result is ready or timeout_time has reached. Returns the status        of this result after unblocking.        Throws errors::empty_result if *this is empty.        Might throw std::bad_alloc if fails to allocate memory.        Might throw std::system_error if one of the underlying synchronization primitives throws.*/template<classclock,classduration >    result_statuswait_until(std::chrono::time_point<clock, duration> timeout_time);/*        Blocks the current thread of execution until this result is ready,        when status() != result_status::idle.        If the result is a valid value, it is returned, otherwise, get rethrows the asynchronous exception.        Throws errors::empty_result if *this is empty.        Might throw std::bad_alloc if fails to allocate memory.        Might throw std::system_error if one of the underlying synchronization primitives throws.*/    typeget();/*        Returns an awaitable used to await this result.        If the result is already ready - the current coroutine resumes        immediately in the calling thread of execution.        If the result is not ready yet, the current coroutine is suspended        and resumed when the asynchronous result is ready,        by the thread which had set the asynchronous value or exception.        In either way, after resuming, if the result is a valid value, it is returned.        Otherwise, operator co_await rethrows the asynchronous exception.        Throws errors::empty_result if *this is empty.*/autooperatorco_await();/*        Returns an awaitable used to resolve this result.        After co_await expression finishes, *this is returned in a non-empty form, in a ready state.        Throws errors::empty_result if *this is empty.*/autoresolve();};

lazy_result type

lazy_result API

classlazy_result {/*        Creates an empty lazy result that isn't associated with any task.*/lazy_result()noexcept =default;/*        Moves the content of rhs to *this. After this call, rhs is empty.*/lazy_result(lazy_result&& rhs)noexcept;/*    Destroys the result. If not empty, the destructor destroys the associated task without resuming it.*/~lazy_result()noexcept;/*        Moves the content of rhs to *this. After this call, rhs is empty. Returns *this.        If *this is not empty, then operator= destroys the associated task without resuming it.*/    lazy_result&operator=(lazy_result&& rhs)noexcept;/*        Returns true if this is a non-empty result.        Applications must not use this object if this->operator bool() is false.*/explicitoperatorbool()constnoexcept;/*        Queries the status of *this.        The returned value is any of result_status::idle, result_status::value or result_status::exception.        Throws errors::empty_result if *this is empty.*/    result_statusstatus()const;/*        Returns an awaitable used to start the associated task and await this result.        If the result is already ready - the current coroutine resumes immediately        in the calling thread of execution.        If the result is not ready yet, the current coroutine is suspended and        resumed when the asynchronous result is ready,        by the thread which had set the asynchronous value or exception.        In either way, after resuming, if the result is a valid value, it is returned.        Otherwise, operator co_await rethrows the asynchronous exception.        Throws errors::empty_result if *this is empty.*/autooperatorco_await();/*        Returns an awaitable used to start the associated task and resolve this result.        If the result is already ready - the current coroutine resumes immediately        in the calling thread of execution.        If the result is not ready yet, the current coroutine is suspended and resumed        when the asynchronous result is ready, by the thread which        had set the asynchronous value or exception.        After co_await expression finishes, *this is returned in a non-empty form, in a ready state.        Throws errors::empty_result if *this is empty.*/autoresolve();/*        Runs the associated task inline and returns a result object that monitors the newly started task.        After this call, *this is empty.        Throws errors::empty_result if *this is empty.        Might throw std::bad_alloc if fails to allocate memory.*/    result<type>run();};

Parallel coroutines

Parallel Fibonacci example:

#include"concurrencpp/concurrencpp.h"#include<iostream>usingnamespaceconcurrencpp;intfibonacci_sync(int i) {if (i ==0) {return0;    }if (i ==1) {return1;    }returnfibonacci_sync(i -1) +fibonacci_sync(i -2);}result<int>fibonacci(executor_tag, std::shared_ptr<thread_pool_executor> tpe,constint curr) {if (curr <=10) {co_returnfibonacci_sync(curr);    }auto fib_1 =fibonacci({}, tpe, curr -1);auto fib_2 =fibonacci({}, tpe, curr -2);co_returnco_await fib_1 +co_await fib_2;}intmain() {    concurrencpp::runtime runtime;auto fibb_30 =fibonacci({}, runtime.thread_pool_executor(),30).get();    std::cout <<"fibonacci(30) =" << fibb_30 << std::endl;return0;}

#include"concurrencpp/concurrencpp.h"#include<iostream>usingnamespaceconcurrencpp;intfibonacci_sync(int i) {if (i ==0) {return0;    }if (i ==1) {return1;    }returnfibonacci_sync(i -1) +fibonacci_sync(i -2);}result<int>fibonacci(std::shared_ptr<thread_pool_executor> tpe,constint curr) {if (curr <=10) {co_returnfibonacci_sync(curr);    }auto fib_1 = tpe->submit(fibonacci, tpe, curr -1);auto fib_2 = tpe->submit(fibonacci, tpe, curr -2);co_returnco_awaitco_await fib_1 +co_awaitco_await fib_2;}intmain() {    concurrencpp::runtime runtime;auto fibb_30 =fibonacci(runtime.thread_pool_executor(),30).get();    std::cout <<"fibonacci(30) =" << fibb_30 << std::endl;return0;}

Result-promises

result_promise API

template<classtype>classresult_promise {/*        Constructs a valid result_promise.        Might throw std::bad_alloc if fails to allocate memory.*/result_promise();/*        Moves the content of rhs to *this. After this call, rhs is empty.*/result_promise(result_promise&& rhs)noexcept;/*        Destroys *this, possibly setting an errors::broken_task exception        by calling set_exception if *this is not empty at the time of destruction.*/~result_promise()noexcept;/*        Moves the content of rhs to *this. After this call, rhs is empty.*/            result_promise&operator = (result_promise&& rhs)noexcept;/*        Returns true if this is a non-empty result-promise.        Applications must not use this object if this->operator bool() is false.*/explicitoperatorbool()constnoexcept;/*        Sets a value by constructing <<type>> from arguments... in-place.        Makes the associated result object become ready - tasks waiting for it        to become ready are unblocked.        Suspended tasks are resumed inline.        After this call, *this becomes empty.        Throws errors::empty_result_promise exception If *this is empty.        Might throw any exception that the constructor        of type(std::forward<argument_types>(arguments)...) throws.*/template<class ... argument_types>voidset_result(argument_types&& ... arguments);/*        Sets an exception.        Makes the associated result object become ready - tasks waiting for it        to become ready are unblocked.        Suspended tasks are resumed inline.        After this call, *this becomes empty.        Throws errors::empty_result_promise exception If *this is empty.        Throws std::invalid_argument exception if exception_ptr is null.*/voidset_exception(std::exception_ptr exception_ptr);/*        A convenience method that invokes a callable with arguments... and calls set_result        with the result of the invocation.        If an exception is thrown, the thrown exception is caught and set instead by calling set_exception.        After this call, *this becomes empty.        Throws errors::empty_result_promise exception If *this is empty.        Might throw any exception that callable(std::forward<argument_types>(arguments)...)        or the contructor of type(type&&) throw.*/template<classcallable_type,class ... argument_types>voidset_from_function(callable_type&& callable, argument_types&& ... arguments);/*        Gets the associated result object.        Throws errors::empty_result_promise exception If *this is empty.        Throws errors::result_already_retrieved exception if this method had been called before.*/    result<type>get_result();};

result_promise example:

#include"concurrencpp/concurrencpp.h"#include<iostream>intmain() {    concurrencpp::result_promise<std::string> promise;auto result = promise.get_result();    std::threadmy_3_party_executor([promise =std::move(promise)] ()mutable {std::this_thread::sleep_for(std::chrono::seconds(1));//Imitate real work        promise.set_result("hello world");    });auto asynchronous_string = result.get();    std::cout <<"result promise returned string:" << asynchronous_string << std::endl;    my_3_party_executor.join();}

Shared result objects

shared_result API

classshare_result {/*        Creates an empty shared-result that isn't associated with any task.*/shared_result()noexcept =default;/*        Destroys the shared-result. Associated tasks are not cancelled.        The destructor does not block waiting for the asynchronous result to become ready.*/~shared_result()noexcept =default;/*        Converts a regular result object to a shared-result object.        After this call, rhs is empty.        Might throw std::bad_alloc if fails to allocate memory.*/shared_result(result<type> rhs);/*        Copy constructor. Creates a copy of the shared result object that monitors the same task.*/shared_result(const shared_result&)noexcept =default;/*        Move constructor. Moves rhs to *this. After this call, rhs is empty.*/shared_result(shared_result&& rhs)noexcept =default;/*        Copy assignment operator. Copies rhs to *this and monitors the same task that rhs monitors.*/            shared_result&operator=(const shared_result& rhs)noexcept;/*        Move assignment operator. Moves rhs to *this. After this call, rhs is empty.*/    shared_result&operator=(shared_result&& rhs)noexcept;/*        Returns true if this is a non-empty shared-result.        Applications must not use this object if this->operator bool() is false.*/explicitoperatorbool()constnoexcept;/*        Queries the status of *this.        The return value is any of result_status::idle, result_status::value or result_status::exception.        Throws errors::empty_result if *this is empty.*/    result_statusstatus()const;/*        Blocks the current thread of execution until this shared-result is ready,        when status() != result_status::idle.        Throws errors::empty_result if *this is empty.        Might throw std::system_error if one of the underlying synchronization primitives throws.*/voidwait();/*        Blocks until this shared-result is ready or duration has passed.        Returns the status of this shared-result after unblocking.        Throws errors::empty_result if *this is empty.        Might throw std::system_error if one of the underlying synchronization primitives throws.*/template<classduration_type,classratio_type>    result_statuswait_for(std::chrono::duration<duration_type, ratio_type> duration);/*        Blocks until this shared-result is ready or timeout_time has reached.        Returns the status of this result after unblocking.        Throws errors::empty_result if *this is empty.        Might throw std::system_error if one of the underlying synchronization primitives throws.*/template<classclock_type,classduration_type>    result_statuswait_until(std::chrono::time_point<clock_type, duration_type> timeout_time);/*        Blocks the current thread of execution until this shared-result is ready,        when status() != result_status::idle.        If the result is a valid value, a reference to it is returned,        otherwise, get rethrows the asynchronous exception.        Throws errors::empty_result if *this is empty.        Might throw std::system_error if one of the underlying synchronization primitives throws.*/    std::add_lvalue_reference_t<type>get();/*        Returns an awaitable used to await this shared-result.        If the shared-result is already ready - the current coroutine resumes        immediately in the calling thread of execution.        If the shared-result is not ready yet, the current coroutine is        suspended and resumed when the asynchronous result is ready,        by the thread which had set the asynchronous value or exception.        In either way, after resuming, if the result is a valid value, a reference to it is returned.        Otherwise, operator co_await rethrows the asynchronous exception.        Throws errors::empty_result if *this is empty.*/autooperatorco_await();/*        Returns an awaitable used to resolve this shared-result.        After co_await expression finishes, *this is returned in a non-empty form, in a ready state.        Throws errors::empty_result if *this is empty.*/autoresolve();};

shared_result example:

#include"concurrencpp/concurrencpp.h"#include<iostream>#include<chrono>concurrencpp::result<void>consume_shared_result(concurrencpp::shared_result<int> shared_result,    std::shared_ptr<concurrencpp::executor> resume_executor) {    std::cout <<"Awaiting shared_result to have a value" << std::endl;constauto& async_value =co_await shared_result;concurrencpp::resume_on(resume_executor);    std::cout <<"In thread id" <<std::this_thread::get_id() <<", got:" << async_value <<", memory address:" << &async_value << std::endl;}intmain() {    concurrencpp::runtime runtime;auto result = runtime.background_executor()->submit([] {std::this_thread::sleep_for(std::chrono::seconds(1));return100;    });    concurrencpp::shared_result<int>shared_result(std::move(result));    concurrencpp::result<void> results[8];for (size_t i =0; i <8; i++) {        results[i] =consume_shared_result(shared_result, runtime.thread_pool_executor());    }    std::cout <<"Main thread waiting for all consumers to finish" << std::endl;auto tpe = runtime.thread_pool_executor();auto all_consumed =concurrencpp::when_all(tpe,std::begin(results),std::end(results)).run();    all_consumed.get();    std::cout <<"All consumers are done, exiting" << std::endl;return0;}

Termination in concurrencpp

Resume executors

Utility functions

make_ready_result function

/*    Creates a ready result object by building <<type>> from arguments&&... in-place.    Might throw any exception that the constructor    of type(std::forward<argument_types>(arguments)...) throws.    Might throw std::bad_alloc exception if fails to allocate memory.*/template<classtype,class ... argument_types>result<type>make_ready_result(argument_types&& ... arguments);/*    An overload for void type.    Might throw std::bad_alloc exception if fails to allocate memory.*/result<void>make_ready_result();

make_exceptional_result function

/*    Creates a ready result object from an exception pointer.    The returned result object will re-throw exception_ptr when calling get or await.    Throws std::invalid_argument if exception_ptr is null.    Might throw std::bad_alloc exception if fails to allocate memory.*/template<classtype>result<type>make_exceptional_result(std::exception_ptr exception_ptr);/*    Overload. Similar to make_exceptional_result(std::exception_ptr),    but gets an exception object directly.    Might throw any exception that the constructor of exception_type(std::move(exception)) might throw.    Might throw std::bad_alloc exception if fails to allocate memory.*/template<classtype,classexception_type>result<type>make_exceptional_result(exception_type exception);

when_all function

/*    Creates a result object that becomes ready when all the input results become ready.    Passed result objects are emptied and returned as a tuple.    Throws std::invalid_argument if any of the passed result objects is empty.    Might throw an std::bad_alloc exception if no memory is available.*/template<class ... result_types>lazy_result<std::tuple<typename std::decay<result_types>::type...>>when_all(std::shared_ptr<executor_type> resume_executor,              result_types&& ... results);/*    Overload. Similar to when_all(result_types&& ...) but receives a pair of iterators referencing a range.    Passed result objects are emptied and returned as a vector.    If begin == end, the function returns immediately with an empty vector.    Throws std::invalid_argument if any of the passed result objects is empty.    Might throw an std::bad_alloc exception if no memory is available.*/template<classiterator_type>lazy_result<std::vector<typename std::iterator_traits<iterator_type>::value_type>>when_all(std::shared_ptr<executor_type> resume_executor,               iterator_type begin, iterator_type end);/*    Overload. Returns a ready result object that doesn't monitor any asynchronous result.    Might throw an std::bad_alloc exception if no memory is available.*/lazy_result<std::tuple<>>when_all(std::shared_ptr<executor_type> resume_executor);

when_any function

/*    Helper struct returned from when_any.    index is the position of the ready result in results sequence.    results is either an std::tuple or an std::vector of the results that were passed to when_any.*/template<classsequence_type>structwhen_any_result {    std::size_t index;    sequence_type results;};/*    Creates a result object that becomes ready when at least one of the input results is ready.    Passed result objects are emptied and returned as a tuple.    Throws std::invalid_argument if any of the passed result objects is empty.    Might throw an std::bad_alloc exception if no memory is available.*/template<class ... result_types>lazy_result<when_any_result<std::tuple<result_types...>>>when_any(std::shared_ptr<executor_type> resume_executor,              result_types&& ... results);/*    Overload. Similar to when_any(result_types&& ...) but receives a pair of iterators referencing a range.    Passed result objects are emptied and returned as a vector.    Throws std::invalid_argument if begin == end.    Throws std::invalid_argument if any of the passed result objects is empty.    Might throw an std::bad_alloc exception if no memory is available.*/template<classiterator_type>lazy_result<when_any_result<std::vector<typename std::iterator_traits<iterator_type>::value_type>>>when_any(std::shared_ptr<executor_type> resume_executor,              iterator_type begin, iterator_type end);

resume_on function

/*    Returns an awaitable that suspends the current coroutine and resumes it inside executor.    Might throw any exception that executor_type::enqueue throws.*/template<classexecutor_type>autoresume_on(std::shared_ptr<executor_type> executor);

Timers and Timer queues

timer_queue API:

classtimer_queue {/*        Destroys this timer_queue.*/~timer_queue()noexcept;/*        Shuts down this timer_queue:        Tells the underlying thread of execution to quit and joins it.        Cancels all pending timers.        After this call, invocation of any method besides shutdown        and shutdown_requested will throw an errors::runtime_shutdown.        If shutdown had been called before, this method has no effect.*/voidshutdown()noexcept;/*        Returns true if shutdown had been called before, false otherwise.*/boolshutdown_requested()constnoexcept;/*        Creates a new running timer where *this is the associated timer_queue.        Throws std::invalid_argument if executor is null.        Throws errors::runtime_shutdown if shutdown had been called before.        Might throw std::bad_alloc if fails to allocate memory.        Might throw std::system_error if the one of the underlying synchronization primitives throws.*/template<classcallable_type,class ... argumet_types>    timermake_timer(        std::chrono::milliseconds due_time,        std::chrono::milliseconds frequency,        std::shared_ptr<concurrencpp::executor> executor,        callable_type&& callable,        argumet_types&& ... arguments);/*        Creates a new one-shot timer where *this is the associated timer_queue.        Throws std::invalid_argument if executor is null.        Throws errors::runtime_shutdown if shutdown had been called before.        Might throw std::bad_alloc if fails to allocate memory.        Might throw std::system_error if the one of the underlying synchronization primitives throws.*/template<classcallable_type,class ... argumet_types>    timermake_one_shot_timer(        std::chrono::milliseconds due_time,        std::shared_ptr<concurrencpp::executor> executor,        callable_type&& callable,        argumet_types&& ... arguments);/*        Creates a new delay object where *this is the associated timer_queue.        Throws std::invalid_argument if executor is null.        Throws errors::runtime_shutdown if shutdown had been called before.        Might throw std::bad_alloc if fails to allocate memory.        Might throw std::system_error if the one of the underlying synchronization primitives throws.*/    result<void>make_delay_object(        std::chrono::milliseconds due_time,        std::shared_ptr<concurrencpp::executor> executor);};

timer API:

classtimer {/*        Creates an empty timer.*/timer()noexcept =default;/*        Cancels the timer, if not empty.*/~timer()noexcept;/*        Moves the content of rhs to *this.        rhs is empty after this call.*/timer(timer&& rhs)noexcept =default;/*        Moves the content of rhs to *this.        rhs is empty after this call.        Returns *this.*/    timer&operator = (timer&& rhs)noexcept;/*        Cancels this timer.        After this call, the associated timer_queue will not schedule *this        to run again and *this becomes empty.        Scheduled, but not yet executed tasks are cancelled.        Ongoing tasks are uneffected.        This method has no effect if *this is empty or the associated timer_queue has already expired.        Might throw std::system_error if one of the underlying synchronization primitives throws.*/voidcancel();/*        Returns the associated executor of this timer.        Throws concurrencpp::errors::empty_timer is *this is empty.*/    std::shared_ptr<executor>get_executor()const;/*        Returns the associated timer_queue of this timer.        Throws concurrencpp::errors::empty_timer is *this is empty.*/    std::weak_ptr<timer_queue>get_timer_queue()const;/*        Returns the due time of this timer.        Throws concurrencpp::errors::empty_timer is *this is empty.*/    std::chrono::millisecondsget_due_time()const;/*        Returns the frequency of this timer.        Throws concurrencpp::errors::empty_timer is *this is empty.*/    std::chrono::millisecondsget_frequency()const;/*        Sets new frequency for this timer.        Callables already scheduled to run at the time of invocation are not affected.        Throws concurrencpp::errors::empty_timer is *this is empty.*/voidset_frequency(std::chrono::milliseconds new_frequency);/*        Returns true is *this is not an empty timer, false otherwise.        The timer should not be used if this->operator bool() is false.*/explicitoperatorbool()constnoexcept;};

Regular timer example:

#include"concurrencpp/concurrencpp.h"#include<iostream>usingnamespacestd::chrono_literals;intmain() {    concurrencpp::runtime runtime;    std::atomic_size_t counter =1;    concurrencpp::timer timer = runtime.timer_queue()->make_timer(        1500ms,        2000ms,        runtime.thread_pool_executor(),        [&] {constauto c = counter.fetch_add(1);            std::cout <<"timer was invoked for the" << c <<"th time" << std::endl;        });std::this_thread::sleep_for(12s);return0;}

Oneshot timers

Oneshot timer example:

#include"concurrencpp/concurrencpp.h"#include<iostream>usingnamespacestd::chrono_literals;intmain() {    concurrencpp::runtime runtime;    concurrencpp::timer timer = runtime.timer_queue()->make_one_shot_timer(        3000ms,        runtime.thread_executor(),        [&] {            std::cout <<"hello and goodbye" << std::endl;        });std::this_thread::sleep_for(4s);return0;}

Delay objects

Delay object example:

#include"concurrencpp/concurrencpp.h"#include<iostream>usingnamespacestd::chrono_literals;concurrencpp::null_resultdelayed_task(    std::shared_ptr<concurrencpp::timer_queue> tq,    std::shared_ptr<concurrencpp::thread_pool_executor> ex) {size_t counter =1;while(true) {        std::cout <<"task was invoked" << counter <<" times." << std::endl;        counter++;co_await tq->make_delay_object(1500ms, ex);    }}intmain() {    concurrencpp::runtime runtime;delayed_task(runtime.timer_queue(), runtime.thread_pool_executor());std::this_thread::sleep_for(10s);return0;}

Generators

generator API

classgenerator {/*        Move constructor. After this call, rhs is empty.*/generator(generator&& rhs)noexcept;/*        Destructor. Invalidates existing iterators.*/~generator()noexcept;generator(const generator& rhs) =delete;    generator&operator=(generator&& rhs) =delete;    generator&operator=(const generator& rhs) =delete;/*        Returns true if this generator is not empty.        Applications must not use this object if this->operator bool() is false.*/explicitoperatorbool()constnoexcept;/*        Starts running this generator and returns an iterator.        Throws errors::empty_generator if *this is empty.        Re-throws any exception that is thrown inside the generator code.*/    iteratorbegin();/*        Returns an end iterator.*/static generator_end_iteratorend()noexcept;};classgenerator_iterator {using value_type = std::remove_reference_t<type>;using reference = value_type&;using pointer = value_type*;using iterator_category = std::input_iterator_tag;using difference_type = std::ptrdiff_t;/*        Resumes the suspended generator and returns *this.        Re-throws any exception that was thrown inside the generator code.*/    generator_iterator&operator++();/*        Post-increment version of operator++.*/voidoperator++(int);/*        Returns the latest value produced by the associated generator.*/    referenceoperator*()constnoexcept;/*        Returns a pointer to the latest value produced by the associated generator.*/    pointeroperator->()constnoexcept;/*        Comparision operators.*/friendbooloperator==(const generator_iterator& it0,const generator_iterator& it1)noexcept;friendbooloperator==(const generator_iterator& it, generator_end_iterator)noexcept;friendbooloperator==(generator_end_iterator end_it,const generator_iterator& it)noexcept;friendbooloperator!=(const generator_iterator& it, generator_end_iterator end_it)noexcept;friendbooloperator!=(generator_end_iterator end_it,const generator_iterator& it)noexcept;};

generator example:

concurrencpp::generator<int>sequence() {int i =1;int sum =0;while (i <=100) {        sum += i;        ++i;co_yield sum;    }}intmain() {for (auto value :sequence()) {        std::cout << value << std::end;    }return0;}

Asynchronous locks

async_lock API

classasync_lock {/*        Constructs an async lock object.*/async_lock()noexcept;/*        Destructs an async lock object.        *this is not automatically unlocked at the moment of destruction.*/~async_lock()noexcept;/*        Asynchronously acquires the async lock.        If *this has already been locked by another non-parent task, the current task will be suspended        and will be resumed when *this is acquired, inside resume_executor.        If *this has not been locked by another task, then *this will be acquired and the current task will be resumed        immediately in the calling thread of execution.        If *this has already been locked by a parent task, then unavoidable dead-lock will occur.        Throws std::invalid_argument if resume_executor is null.        Throws std::system error if one of the underlying synhchronization primitives throws.*/    lazy_result<scoped_async_lock>lock(std::shared_ptr<executor> resume_executor);/*        Tries to acquire *this in the calling thread of execution.        Returns true if *this is acquired, false otherwise.        In any case, the current task is resumed immediately in the calling thread of execution.        Throws std::system error if one of the underlying synhchronization primitives throws.*/    lazy_result<bool>try_lock();/*        Releases *this and allows other tasks (including suspended tasks waiting for *this) to acquire it.        Throws std::system error if *this is not locked at the moment of calling this method.        Throws std::system error if one of the underlying synhchronization primitives throws.*/voidunlock();};

scoped_async_lock API

classscoped_async_lock {/*        Constructs an async lock wrapper that does not wrap any async lock.*/scoped_async_lock()noexcept =default;/*        If *this wraps async_lock, this method releases the wrapped lock.*/~scoped_async_lock()noexcept;/*        Moves rhs to *this.        After this call, *rhs does not wrap any async lock.*/scoped_async_lock(scoped_async_lock&& rhs)noexcept;/*        Wrapps unlocked lock.        lock must not be in acquired mode when calling this method.*/scoped_async_lock(async_lock& lock, std::defer_lock_t)noexcept;/*        Wrapps locked lock.        lock must be already acquired when calling this method.*/scoped_async_lock(async_lock& lock, std::adopt_lock_t)noexcept;/*        Calls async_lock::lock on the wrapped locked, using resume_executor as a parameter.        Throws std::invalid_argument if resume_executor is nulll.        Throws std::system_error if *this does not wrap any lock.        Throws std::system_error if wrapped lock is already locked.        Throws any exception async_lock::lock throws.*/    lazy_result<void>lock(std::shared_ptr<executor> resume_executor);/*        Calls async_lock::try_lock on the wrapped lock.        Throws std::system_error if *this does not wrap any lock.        Throws std::system_error if wrapped lock is already locked.        Throws any exception async_lock::try_lock throws.*/    lazy_result<bool>try_lock();/*        Calls async_lock::unlock on the wrapped lock.        If *this does not wrap any lock, this method does nothing.        Throws std::system_error if *this wraps a lock and it is not locked.*/voidunlock();/*        Checks whether *this wraps a locked mutex or not.        Returns true if wrapped locked is in acquired state, false otherwise.*/boolowns_lock()constnoexcept;/*        Equivalent to owns_lock.*/explicitoperatorbool()constnoexcept;/*        Swaps the contents of *this and rhs.*/voidswap(scoped_async_lock& rhs)noexcept;/*        Empties *this and returns a pointer to the previously wrapped lock.        After a call to this method, *this doesn't wrap any lock.        The previously wrapped lock is not released,        it must be released by either unlocking it manually through the returned pointer or by        capturing the pointer with another scoped_async_lock which will take ownerwhip over it.*/    async_lock*release()noexcept;/*        Returns a pointer to the wrapped async_lock, or a null pointer if there is no wrapped async_lock.*/    async_lock*mutex()constnoexcept;};

async_lock example:

#include"concurrencpp/concurrencpp.h"#include<vector>#include<iostream>std::vector<size_t> numbers;concurrencpp::async_lock lock;concurrencpp::result<void>add_numbers(concurrencpp::executor_tag,                                       std::shared_ptr<concurrencpp::executor> executor,size_t begin,size_t end) {for (auto i = begin; i < end; i++) {        concurrencpp::scoped_async_lock raii_wrapper =co_await lock.lock(executor);        numbers.push_back(i);    }}intmain() {    concurrencpp::runtime runtime;constexprsize_t range =10'000'000;constexprsize_t sections =4;    concurrencpp::result<void> results[sections];for (size_t i =0; i <4; i++) {constauto range_start = i * range / sections;constauto range_end = (i +1) * range / sections;        results[i] =add_numbers({}, runtime.thread_pool_executor(), range_start, range_end);    }for (auto& result : results) {        result.get();    }    std::cout <<"vector size is" << numbers.size() << std::endl;// make sure the vector state has not been corrupted by unprotected concurrent accessesstd::sort(numbers.begin(), numbers.end());for (size_t i =0; i < range; i++) {if (numbers[i] != i) {            std::cerr <<"vector state is corrupted." << std::endl;return -1;        }    }    std::cout <<"succeeded pushing range [0 - 10,000,000] concurrently to the vector!" << std::endl;return0;}

Asynchronous condition variables

while (!pred()) {// pred() inspects the shared memory and returns true or falseco_awaitawait(resume_executor, lock);// suspend the current task until another task calls `notify_xxx`}

async_condition_variable API

classasync_condition_variable {/*Constructor.*/async_condition_variable()noexcept;/*Atomically releases lock and suspends the current task by adding it to *this suspension-queue.Throws std::invalid_argument if resume_executor is null.Throws std::invalid_argument if lock is not locked at the moment of calling this method.Might throw std::system_error if the underlying std::mutex throws.*/lazy_result<void>await(std::shared_ptr<executor> resume_executor, scoped_async_lock& lock);/*Equivalent to:while (!pred()) {            co_await await(resume_executor, lock);        }Might throw any exception that await(resume_executor, lock) might throw.Might throw any exception that pred might throw.*/template<classpredicate_type>lazy_result<void>await(std::shared_ptr<executor> resume_executor, scoped_async_lock& lock, predicate_type pred);/*Dequeues one task from *this suspension-queue and resumes it, if any available at the moment of calling this method.The suspended task is resumed by scheduling it to run on the executor given when await was called.Might throw std::system_error if the underlying std::mutex throws.*/voidnotify_one();/*Dequeues all tasks from *this suspension-queue and resumes them, if any available at the moment of calling this method.The suspended tasks are resumed by scheduling them to run on the executors given when await was called.Might throw std::system_error if the underlying std::mutex throws.*/voidnotify_all();};

async_condition_variable example:

#include"concurrencpp/concurrencpp.h"#include<queue>#include<iostream>usingnamespaceconcurrencpp;classconcurrent_queue {private:    async_lock _lock;    async_condition_variable _cv;    std::queue<int> _queue;bool _abort =false;public:concurrent_queue() =default;    result<void>shutdown(std::shared_ptr<executor> resume_executor) {        {auto guard =co_await _lock.lock(resume_executor);            _abort =true;        }        _cv.notify_all();    }    lazy_result<void>push(std::shared_ptr<executor> resume_executor,int i) {        {auto guard =co_await _lock.lock(resume_executor);            _queue.push(i);        }        _cv.notify_one();    }    lazy_result<int>pop(std::shared_ptr<executor> resume_executor) {auto guard =co_await _lock.lock(resume_executor);co_await _cv.await(resume_executor, guard, [this] {return _abort || !_queue.empty();        });if (!_queue.empty()) {auto result = _queue.front();            _queue.pop();co_return result;                }assert(_abort);throwstd::runtime_error("queue has been shut down.");    }};result<void>producer_loop(executor_tag,                           std::shared_ptr<thread_pool_executor> tpe,                           concurrent_queue& queue,int range_start,int range_end) {for (; range_start < range_end; ++range_start) {co_await queue.push(tpe, range_start);    }}result<void>consumer_loop(executor_tag, std::shared_ptr<thread_pool_executor> tpe, concurrent_queue& queue) {try {while (true) {            std::cout <<co_await queue.pop(tpe) << std::endl;        }    }catch (const std::exception& e) {        std::cerr << e.what() << std::endl;    }}intmain() {    runtime runtime;constauto thread_pool_executor = runtime.thread_pool_executor();    concurrent_queue queue;    result<void> producers[4];    result<void> consumers[4];for (int i =0; i <4; i++) {        producers[i] =producer_loop({}, thread_pool_executor, queue, i *5, (i +1) *5);    }for (int i =0; i <4; i++) {        consumers[i] =consumer_loop({}, thread_pool_executor, queue);    }for (int i =0; i <4; i++) {        producers[i].get();    }    queue.shutdown(thread_pool_executor).get();for (int i =0; i <4; i++) {        consumers[i].get();    }return0;}

The runtime object

runtime API

classruntime {/*        Creates a runtime object with default options.*/runtime();/*        Creates a runtime object with user defined options.*/runtime(const concurrencpp::runtime_options& options);/*        Destroys this runtime object.        Calls executor::shutdown on each monitored executor.        Calls timer_queue::shutdown on the global timer queue.*/~runtime()noexcept;/*        Returns this runtime timer queue used to create new times.*/    std::shared_ptr<concurrencpp::timer_queue>timer_queue()constnoexcept;/*        Returns this runtime concurrencpp::inline_executor*/    std::shared_ptr<concurrencpp::inline_executor>inline_executor()constnoexcept;/*        Returns this runtime concurrencpp::thread_pool_executor*/    std::shared_ptr<concurrencpp::thread_pool_executor>thread_pool_executor()constnoexcept;/*        Returns this runtime concurrencpp::background_executor*/    std::shared_ptr<concurrencpp::thread_pool_executor>background_executor()constnoexcept;/*        Returns this runtime concurrencpp::thread_executor*/    std::shared_ptr<concurrencpp::thread_executor>thread_executor()constnoexcept;/*        Creates a new concurrencpp::worker_thread_executor and registers it in this runtime.        Might throw std::bad_alloc or std::system_error if any underlying memory or system resource could not have been acquired.*/    std::shared_ptr<concurrencpp::worker_thread_executor>make_worker_thread_executor();/*        Creates a new concurrencpp::manual_executor and registers it in this runtime.        Might throw std::bad_alloc or std::system_error if any underlying memory or system resource could not have been acquired.*/    std::shared_ptr<concurrencpp::manual_executor>make_manual_executor();/*        Creates a new user defined executor and registers it in this runtime.        executor_type must be a valid concrete class of concurrencpp::executor.        Might throw std::bad_alloc if no memory is available.        Might throw any exception that the constructor of <<executor_type>> might throw.*/template<classexecutor_type,class ... argument_types>    std::shared_ptr<executor_type>make_executor(argument_types&& ... arguments);/*        returns the version of concurrencpp that the library was built with.*/static std::tuple<unsignedint,unsignedint,unsignedint>version()noexcept;};

Thread creation and termination monitoring

Example: monitoring thread creation and termination

#include"concurrencpp/concurrencpp.h"#include<iostream>intmain() {    concurrencpp::runtime_options options;    options.thread_started_callback = [](std::string_view thread_name) {        std::cout <<"A new thread is starting to run, name:" << thread_name <<", thread id:" <<std::this_thread::get_id()                  << std::endl;    };    options.thread_terminated_callback = [](std::string_view thread_name) {        std::cout <<"A thread is terminating, name:" << thread_name <<", thread id:" <<std::this_thread::get_id() << std::endl;    };    concurrencpp::runtimeruntime(options);constauto timer_queue = runtime.timer_queue();constauto thread_pool_executor = runtime.thread_pool_executor();    concurrencpp::timer timer =        timer_queue->make_timer(std::chrono::milliseconds(100),std::chrono::milliseconds(500), thread_pool_executor, [] {            std::cout <<"A timer callable is executing" << std::endl;        });std::this_thread::sleep_for(std::chrono::seconds(3));return0;}

A new thread is starting to run, name: concurrencpp::timer_queue worker, thread id: 7496A new thread is starting to run, name: concurrencpp::thread_pool_executor worker, thread id: 21620A timer callable is executingA timer callable is executingA timer callable is executingA timer callable is executingA timer callable is executingA timer callable is executingA thread is terminating, name: concurrencpp::timer_queue worker, thread id: 7496A thread is terminating, name: concurrencpp::thread_pool_executor worker, thread id: 21620

Creating user-defined executors

task objects

task API

classtask {/*        Creates an empty task object.*/task()noexcept;/*        Creates a task object by moving the stored callable of rhs to *this.        If rhs is empty, then *this will also be empty after construction.        After this call, rhs is empty.*/task(task&& rhs)noexcept;/*        Creates a task object by storing callable in *this.        <<typename std::decay<callable_type>::type>> will be in-place-        constructed inside *this by perfect forwarding callable.*/template<classcallable_type>task(callable_type&& callable);/*        Destroys stored callable, does nothing if empty.*/~task()noexcept;/*        If *this is empty, does nothing.        Invokes stored callable, and immediately destroys it.        After this call, *this is empty.        May throw any exception that the invoked callable may throw.*/voidoperator()();/*        Moves the stored callable of rhs to *this.        If rhs is empty, then *this will also be empty after this call.        If *this already contains a stored callable, operator = destroys it first.*/    task&operator=(task&& rhs)noexcept;/*        If *this is not empty, task::clear destroys the stored callable and empties *this.        If *this is empty, clear does nothing.*/voidclear()noexcept;/*        Returns true if *this stores a callable. false otherwise.*/explicitoperatorbool()constnoexcept;/*        Returns true if *this stores a callable,        and that stored callable has the same type as <<typename std::decay<callable_type>::type>>*/template<classcallable_type>boolcontains()constnoexcept;};

Example: writing a user-defined executor:

#include"concurrencpp/concurrencpp.h"#include<iostream>#include<queue>#include<thread>#include<mutex>#include<condition_variable>classlogging_executor :publicconcurrencpp::derivable_executor<logging_executor> {private:mutable std::mutex _lock;    std::queue<concurrencpp::task> _queue;    std::condition_variable _condition;bool _shutdown_requested;    std::thread _thread;const std::string _prefix;voidwork_loop() {while (true) {            std::unique_lock<std::mutex>lock(_lock);if (_shutdown_requested) {return;            }if (!_queue.empty()) {auto task =std::move(_queue.front());                _queue.pop();                lock.unlock();                std::cout << _prefix <<" A task is being executed" << std::endl;task();continue;            }            _condition.wait(lock, [this] {return !_queue.empty() || _shutdown_requested;            });        }    }public:logging_executor(std::string_view prefix) :        derivable_executor<logging_executor>("logging_executor"),_shutdown_requested(false),_prefix(prefix) {        _thread =std::thread([this] {work_loop();        });    }voidenqueue(concurrencpp::task task)override {        std::cout << _prefix <<" A task is being enqueued!" << std::endl;        std::unique_lock<std::mutex>lock(_lock);if (_shutdown_requested) {throwconcurrencpp::errors::runtime_shutdown("logging executor - executor was shutdown.");        }        _queue.emplace(std::move(task));        _condition.notify_one();    }voidenqueue(std::span<concurrencpp::task> tasks)override {        std::cout << _prefix << tasks.size() <<" tasks are being enqueued!" << std::endl;        std::unique_lock<std::mutex>lock(_lock);if (_shutdown_requested) {throwconcurrencpp::errors::runtime_shutdown("logging executor - executor was shutdown.");        }for (auto& task : tasks) {            _queue.emplace(std::move(task));        }        _condition.notify_one();    }intmax_concurrency_level()constnoexceptoverride {return1;    }boolshutdown_requested()constnoexceptoverride {        std::unique_lock<std::mutex>lock(_lock);return _shutdown_requested;    }voidshutdown()noexceptoverride {        std::cout << _prefix <<" shutdown requested" << std::endl;        std::unique_lock<std::mutex>lock(_lock);if (_shutdown_requested)return;//nothing to do.        _shutdown_requested =true;        lock.unlock();        _condition.notify_one();        _thread.join();    }};intmain() {    concurrencpp::runtime runtime;auto logging_ex = runtime.make_executor<logging_executor>("Session #1234");for (size_t i =0; i <10; i++) {        logging_ex->post([] {            std::cout <<"hello world" << std::endl;        });    }std::getchar();return0;}

Supported platforms and tools

Building, installing and testing

Building the library on Windows (release mode)

$ git clone https://github.com/David-Haim/concurrencpp.git$ cd concurrencpp$ cmake -S . -Bbuild/lib$ cmake --buildbuild/lib --config Release

Running the tests on Windows (debug + release mode)

$ git clone https://github.com/David-Haim/concurrencpp.git$ cd concurrencpp$ cmake -Stest -Bbuild/test$ cmake --buildbuild/test    <# for release mode: cmake --build build/test --config Release #>$ cdbuild/test$ ctest . -V -C Debug    <# for release mode: ctest . -V -C Release #>

Building the library on *nix platforms (release mode)

$ git clone https://github.com/David-Haim/concurrencpp.git$ cd concurrencpp$ cmake -DCMAKE_BUILD_TYPE=Release -S . -Bbuild/lib$ cmake --buildbuild/lib#optional, install the library: sudo cmake --install build/lib

Running the tests on *nix platforms

$ git clone https://github.com/David-Haim/concurrencpp.git$ cd concurrencpp$ cmake -Stest -Bbuild/test#for release mode: cmake -DCMAKE_BUILD_TYPE=Release -S test -B build/test#for TSAN mode: cmake -DCMAKE_BUILD_TYPE=Release -DENABLE_THREAD_SANITIZER=Yes -S test -B build/test$ cmake --buildbuild/test  $ cdbuild/test$ ctest . -V

Important note regarding Linux and libc++

$ cmake -DCMAKE_TOOLCHAIN_FILE=../cmake/libc++.cmake -DCMAKE_BUILD_TYPE=Release -S . -Bbuild/lib

Installing concurrencpp with vcpkg or Conan

$ vcpkg install concurrencpp

Experimenting with the built-in sandbox

Building and running the sandbox on Windows:

$ cmake -S sandbox -Bbuild/sandbox$ cmake --buildbuild/sandbox    <# for release mode: cmake --build build/sandbox --config Release #>$ ./build/sandbox <# runs the sandbox>

Building and running the sandbox on *nix platforms:

$ cmake -S sandbox -Bbuild/sandbox#for release mode: cmake -DCMAKE_BUILD_TYPE=Release -S sandbox -B build/sandbox$ cmake --buildbuild/sandbox  $ ./build/sandbox#runs the sandbox