tf::AsyncTask taskflow/core/async_task.hpp class friend class Executor Executor Executor Node * Node* tf::AsyncTask::_node _node {nullptr} tf::AsyncTask::AsyncTask ()=default AsyncTask constructs an empty task handle tf::AsyncTask::~AsyncTask () ~AsyncTask destroys the managed async task if this is the last owner tf::AsyncTask::AsyncTask (const AsyncTask &rhs) AsyncTask const AsyncTask & rhs constructs an async task that shares ownership of rhs tf::AsyncTask::AsyncTask (AsyncTask &&rhs) AsyncTask AsyncTask && rhs move-constructs an async task from rhs AsyncTask & AsyncTask & tf::AsyncTask::operator= (const AsyncTask &rhs) operator= const AsyncTask & rhs copy-assigns the async task from rhs Releases the managed object of this and retains a new shared ownership of rhs. AsyncTask & AsyncTask & tf::AsyncTask::operator= (AsyncTask &&rhs) operator= AsyncTask && rhs move-assigns the async task from rhs Releases the managed object of this and takes over the ownership of rhs. bool bool tf::AsyncTask::empty () const empty checks if this async task is associated with a callable void void tf::AsyncTask::reset () reset release the managed object of this size_t size_t tf::AsyncTask::hash_value () const hash_value obtains the hashed value of this async task size_t size_t tf::AsyncTask::use_count () const use_count returns the number of shared owners that are currently managing this async task bool bool tf::AsyncTask::is_done () const is_done checks if the async task finishes tf::AsyncTask::AsyncTask (Node *) AsyncTask Node * ptr void void tf::AsyncTask::_incref () _incref void void tf::AsyncTask::_decref () _decref class to create a dependent asynchronous task (async task) A tf::AsyncTask is a lightweight handle that retains shared ownership of a dependent asynchronous task (async task) created by an executor. This shared ownership ensures that the async task remains alive when adding it to the dependency list of another async task, thus avoiding the classical ABA problem. //mainthreadretainssharedownershipofasynctaskA tf::AsyncTaskA=executor.silent_dependent_async([](){}); //taskAremainsalive(i.e.,atleastonerefcountbythemainthread) //whenbeingaddedtothedependencylistofasynctaskB tf::AsyncTaskB=executor.silent_dependent_async([](){},A); Currently, tf::AsyncTask is implemented based on the logic of C++ smart pointer std::shared_ptr and is considered cheap to copy or move as long as only a handful of objects own it. When a worker completes an async task, it will remove the task from the executor, decrementing the number of shared owners by one. If that counter reaches zero, the task is destroyed. tf::AsyncTask_decref tf::AsyncTask_incref tf::AsyncTask_node tf::AsyncTaskAsyncTask tf::AsyncTaskAsyncTask tf::AsyncTaskAsyncTask tf::AsyncTaskAsyncTask tf::AsyncTaskempty tf::AsyncTaskExecutor tf::AsyncTaskhash_value tf::AsyncTaskis_done tf::AsyncTaskoperator= tf::AsyncTaskoperator= tf::AsyncTaskreset tf::AsyncTaskuse_count tf::AsyncTask~AsyncTask