Asynchronous Programming in C++: How to Achieve Async/Await Like in JavaScript

Asynchronous programming has become a fundamental part of modern application development, especially with the need to execute long-running tasks without blocking the user interface or halting the program. In languages like JavaScript, the Async/Await pattern is used to simplify writing asynchronous code, making it appear synchronous. But how can this pattern be achieved in a language like C++? In this article, we will explore how to represent asynchronous programming in C++ using Async/Await and how this approach can be useful in certain scenarios.

What is Asynchronous Programming?

Asynchronous programming allows long-running tasks (such as network requests or file access) to be executed without blocking the main program. Instead of waiting for the task to complete, the program can continue executing other tasks and then return to process the result once the asynchronous task is finished.

In JavaScript, this is easily achieved using the Async/Await keywords, which make asynchronous code look synchronous and easy to read.

Asynchronous Programming in C++

In C++, asynchronous programming can be achieved using the std::async and std::future libraries, as well as features like coroutines introduced in C++20. These tools allow writing asynchronous code in a manner similar to Async/Await in JavaScript.

1. Using std::async and std::future

The std::async library allows a function to be executed asynchronously, while std::future is used to retrieve the result once the execution is complete. This is somewhat similar to using Promises in JavaScript.

​x
#include <iostream>
#include <future>
#include <thread>
#include <chrono>

int longRunningTask() {
    std::this_thread::sleep_for(std::chrono::seconds(2)); // Simulate a long-running task
    return 42;
}

int main() {
    // Execute the task asynchronously
    std::future<int> result = std::async(std::launch::async, longRunningTask);

    // Continue executing other tasks
    std::cout << "Waiting for the result..." << std::endl;

    // Wait for the result (similar to await)
    int value = result.get();
    std::cout << "Result: " << value << std::endl;

    return 0;
}

In this example, the longRunningTask function is executed asynchronously, while the main program continues to execute other tasks. When the result is needed, result.get() is used to wait for the task to complete.

2. Using Coroutines in C++20

With the release of C++20, the Coroutines feature was introduced, allowing asynchronous code to be written in a manner similar to Async/Await in JavaScript. Coroutines are functions that can be paused and resumed, making them ideal for asynchronous programming.

xxxxxxxxxx
#include <iostream>
#include <coroutine>
#include <chrono>
#include <thread>

// Define a structure for the Coroutine
struct Task {
    struct promise_type {
        Task get_return_object() { return {}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {}
    };
};

// Asynchronous function (Coroutine)
Task asyncTask() {
    std::cout << "Starting async task..." << std::endl;
    co_await std::suspend_always{}; // Pause execution
    std::this_thread::sleep_for(std::chrono::seconds(2)); // Simulate a long-running task
    std::cout << "Async task completed!" << std::endl;
}

int main() {
    asyncTask(); // Start the asynchronous task
    std::cout << "Main thread continues..." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(3)); // Wait to see the result
    return 0;
}

In this example, Coroutines are used to execute an asynchronous task. The co_await keyword is used to pause execution, allowing the main program to continue executing other tasks.

Use Cases for Asynchronous Programming in C++

1. Graphical User Interface (GUI) Applications: In GUI applications, asynchronous programming can be used to prevent the interface from freezing when executing long-running tasks such as loading data or processing files.

2. Network Applications: When dealing with network requests (such as HTTP or WebSocket), asynchronous programming can be used to execute requests without blocking the main program.

3. Big Data Processing: In applications that require processing large amounts of data, asynchronous programming can be used to improve performance and reduce waiting time.

Comparison Between C++ and JavaScript

Conclusion

Asynchronous programming in C++ has become more powerful and easier with the introduction of features like Coroutines in C++20. Although writing asynchronous code in C++ may require more effort compared to languages like JavaScript, the high performance and flexibility offered by C++ make it an excellent choice for applications that require precise control over resources and performance.

If you are working on applications that require executing long-running tasks without blocking the main program, learning asynchronous programming in C++ will be a valuable addition to your programming skills.