C++ async is a function template from the <future> header that helps you execute functions asynchronously, potentially in separate threads. It returns a std::future object that you can use to track the progress and retrieve the result of the asynchronous task.
Key Concepts:
Asynchronous Execution: async launches the provided function in a different thread (or using other mechanisms) without blocking the calling thread. This allows your program to continue doing other work while the asynchronous task is running.
std::future: The std::future object returned by async serves as a placeholder for the result of the asynchronous task. You can use methods like get(), wait(), valid(), and ready() to manage and access the result.
Common Use Cases:
Performing I/O-bound operations (e.g., network requests, file reading/writing) without blocking the main thread.
Source Code:
/*
* Callback.h
*
* Created on: 28-Dec-2023
* Author: ridit
*/
#ifndef CALLBACK_H_
#define CALLBACK_H_
class CallBack {
public:
virtual void onStartTask() = 0;
virtual void onFinishTask() = 0;
};
#endif /* CALLBACK_H_ */
/*
* Caller.h
*
* Created on: Feb 15, 2024
* Author: som
*/
#ifndef CALLER_H_
#define CALLER_H_
#include <iostream>
#include "Callee.h"
using namespace std;
//forward declaration
class Callee;
class Caller : public CallBack{
private:
Callee* callee;
public:
Caller(){
callee = new Callee(this);
}
void doOwnTask(){
cout<<"Main thread id = " <<this_thread::get_id()<<endl;
for(int i = 0;i<10;i++){
cout<<"Caller is doing its own task in the main thread..."<<endl;
}
}
void delegateTaskToCallee(){
callee->doBackgroundTask();
}
virtual ~Caller(){
}
void onStartTask(){
cout<<"The background task is starting"<<endl;
}
void onFinishTask(){
cout<<"The background task is finished. Thank you, Callee, for taking my burden"<<endl;
}
};
#endif /* CALLER_H_ */
/*
* Callee.h
*
* Created on: Feb 15, 2024
* Author: som
*/
#ifndef CALLEE_H_
#define CALLEE_H_
#include <iostream>
#include <future>
#include "CallBack.h"
using namespace std;
class Callee {
private:
CallBack* cb;
public:
Callee(CallBack* cb){
this->cb = cb;
}
virtual ~Callee(){
}
static bool task(){
cout<<"Background thread id = " <<this_thread::get_id()<<endl;
for(int i = 0;i<10;i++){
cout<<"Callee is doing the background task"<<endl;
}
return true;
}
void doBackgroundTask(){
this->cb->onStartTask();
future<bool> futureTask = async(launch::async, Callee::task);
if(futureTask.get() == true){
this->cb->onFinishTask();
}
}
};
#endif /* CALLEE_H_ */
//============================================================================
// Name : Callback.cpp
// Author : Som
// Version :
// Copyright : som-itsolutions
// Description : Hello World in C++, Ansi-style
//============================================================================
#include <iostream>
#include "CallBack.h"
#include "Caller.h"
#include "Callee.h"
using namespace std;
int main() {
Caller* caller = new Caller();
caller->doOwnTask();
caller->delegateTaskToCallee();
return 0;
}
You may like my other research study vis-a-vis how the
evenlistener pattern has been implemented in Android UI input
events.
Here we go...
