使用C++11的`std::future`和`std::promise`实现异步网络通信

最新推荐文章于 2024-10-13 12:52:22 发布
最新推荐文章于 2024-10-13 12:52:22 发布
阅读量818 收藏 16
点赞数 21
分类专栏： C++题库 面试试题 C++ 文章标签： c++ java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/windowshht/article/details/142009329
版权
面试试题 同时被 3 个专栏收录
75 篇文章 0 订阅
订阅专栏
C++
69 篇文章 0 订阅
订阅专栏
C++题库
67 篇文章 0 订阅
订阅专栏

使用C++11的std::future和std::promise实现异步网络通信

在现代C++编程中，异步编程是一个重要的主题。C++11引入了std::future和std::promise，为异步编程提供了强大的工具。本文将详细介绍如何使用std::future和std::promise实现异步网络通信，并提供丰富的示例代码。

什么是std::future和std::promise？

std::future和std::promise是C++11标准库中的两个类，用于实现异步操作：

  • std::promise：用于设置一个值或异常，该值或异常可以在另一个线程中被获取。
  • std::future：用于获取由std::promise设置的值或异常。

通过std::promise和std::future，我们可以在一个线程中启动一个异步操作，并在另一个线程中等待其完成。

实现异步网络通信的步骤
  1. 创建Socket：使用socket函数创建一个Socket。
  2. 连接服务器：使用connect函数连接到服务器。
  3. 发送和接收消息：使用send和recv函数进行消息传递。
  4. 使用std::promise和std::future：在异步操作中使用std::promise和std::future来实现异步通信。
示例代码

以下是实现一个简单的异步TCP客户端的完整代码示例：

#include <iostream>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <future>

const int PORT = 8080;
const int BUFFER_SIZE = 1024;

std::string async_send_receive(const std::string& server_ip, const std::string& message) {
    // 创建Socket
    int client_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (client_socket == -1) {
        throw std::runtime_error("Failed to create socket");
    }

    // 服务器地址
    sockaddr_in server_addr;
    std::memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    inet_pton(AF_INET, server_ip.c_str(), &server_addr.sin_addr);

    // 连接服务器
    if (connect(client_socket, (sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        close(client_socket);
        throw std::runtime_error("Failed to connect to server");
    }

    // 发送消息
    send(client_socket, message.c_str(), message.size(), 0);

    // 接收响应
    char buffer[BUFFER_SIZE];
    std::memset(buffer, 0, BUFFER_SIZE);
    int bytes_received = recv(client_socket, buffer, BUFFER_SIZE, 0);
    if (bytes_received < 0) {
        close(client_socket);
        throw std::runtime_error("Failed to receive response");
    }

    // 关闭连接
    close(client_socket);

    return std::string(buffer, bytes_received);
}

int main() {
    std::string server_ip = "127.0.0.1";
    std::string message = "Hello, Server!";

    // 创建promise和future
    std::promise<std::string> promise;
    std::future<std::string> future = promise.get_future();

    // 启动异步任务
    std::thread([&promise, &server_ip, &message]() {
        try {
            std::string response = async_send_receive(server_ip, message);
            promise.set_value(response);
        } catch (const std::exception& e) {
            promise.set_exception(std::current_exception());
        }
    }).detach();

    // 等待并获取结果
    try {
        std::string response = future.get();
        std::cout << "Received response: " << response << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    return 0;
}
代码解析

  1. 创建Socket：

    int client_socket = socket(AF_INET, SOCK_STREAM, 0);
if (client_socket == -1) {
    throw std::runtime_error("Failed to create socket");
}

    这行代码创建了一个TCP Socket。AF_INET表示使用IPv4地址，SOCK_STREAM表示使用TCP协议。

  2. 连接服务器：

    sockaddr_in server_addr;
std::memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(PORT);
inet_pton(AF_INET, server_ip.c_str(), &server_addr.sin_addr);

if (connect(client_socket, (sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
    close(client_socket);
    throw std::runtime_error("Failed to connect to server");
}

    这段代码将客户端连接到指定的服务器地址和端口。

  3. 发送和接收消息：

    send(client_socket, message.c_str(), message.size(), 0);

char buffer[BUFFER_SIZE];
std::memset(buffer, 0, BUFFER_SIZE);
int bytes_received = recv(client_socket, buffer, BUFFER_SIZE, 0);
if (bytes_received < 0) {
    close(client_socket);
    throw std::runtime_error("Failed to receive response");
}

close(client_socket);

return std::string(buffer, bytes_received);

    这段代码发送消息给服务器，然后等待接收服务器的响应。接收到响应后，关闭连接并返回响应内容。

  4. 使用std::promise和std::future：

    std::promise<std::string> promise;
std::future<std::string> future = promise.get_future();

std::thread([&promise, &server_ip, &message]() {
    try {
        std::string response = async_send_receive(server_ip, message);
        promise.set_value(response);
    } catch (const std::exception& e) {
        promise.set_exception(std::current_exception());
    }
}).detach();

try {
    std::string response = future.get();
    std::cout << "Received response: " << response << std::endl;
} catch (const std::exception& e) {
    std::cerr << "Error: " << e.what() << std::endl;
}

    这段代码创建了一个std::promise对象，并通过get_future方法获取对应的std::future对象。然后启动一个新线程，在新线程中执行异步任务，并将结果设置到std::promise中。主线程等待std::future获取结果，并处理异常。

进一步优化

虽然上述代码实现了一个基本的异步TCP客户端，但在实际应用中，我们可能需要进一步优化和扩展功能：

  1. 错误处理：添加更多的错误处理逻辑，处理各种可能的网络错误。
  2. 超时机制：实现超时机制，避免异步操作无限期等待。
  3. 多线程处理：使用线程池或异步I/O来提高并发性能。
  4. 数据序列化：使用数据序列化技术（如JSON或Protobuf）来传输复杂的数据结构。
超时机制示例

以下是一个实现超时机制的示例：

#include <iostream>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <future>
#include <chrono>

const int PORT = 8080;
const int BUFFER_SIZE = 1024;

std::string async_send_receive(const std::string& server_ip, const std::string& message) {
    // 创建Socket
    int client_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (client_socket == -1) {
        throw std::runtime_error("Failed to create socket");
    }

    // 服务器地址
    sockaddr_in server_addr;
    std::memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    inet_pton(AF_INET, server_ip.c_str(), &server_addr.sin_addr);

    // 连接服务器
    if (connect(client_socket, (sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        close(client_socket);
        throw std::runtime_error("Failed to connect to server");
    }

    // 发送消息
    send(client_socket, message.c_str(), message.size(), 0);

    // 接收响应
    char buffer[BUFFER_SIZE];
    std::memset(buffer, 0, BUFFER_SIZE);
    int bytes_received = recv(client_socket, buffer, BUFFER_SIZE, 0);
    if (bytes_received < 0) {
        close(client_socket);
        throw std::runtime_error("Failed to receive response");
    }

    // 关闭连接
    close(client_socket);

    return std::string(buffer, bytes_received);
}

int main() {
    std::string server_ip = "127.好的，我们继续。

#### 超时机制示例（续）

以下是一个实现超时机制的完整示例：

```cpp
#include <iostream>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <future>
#include <chrono>

const int PORT = 8080;
const int BUFFER_SIZE = 1024;

std::string async_send_receive(const std::string& server_ip, const std::string& message) {
    // 创建Socket
    int client_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (client_socket == -1) {
        throw std::runtime_error("Failed to create socket");
    }

    // 服务器地址
    sockaddr_in server_addr;
    std::memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    inet_pton(AF_INET, server_ip.c_str(), &server_addr.sin_addr);

    // 连接服务器
    if (connect(client_socket, (sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        close(client_socket);
        throw std::runtime_error("Failed to connect to server");
    }

    // 发送消息
    send(client_socket, message.c_str(), message.size(), 0);

    // 接收响应
    char buffer[BUFFER_SIZE];
    std::memset(buffer, 0, BUFFER_SIZE);
    int bytes_received = recv(client_socket, buffer, BUFFER_SIZE, 0);
    if (bytes_received < 0) {
        close(client_socket);
        throw std::runtime_error("Failed to receive response");
    }

    // 关闭连接
    close(client_socket);

    return std::string(buffer, bytes_received);
}

int main() {
    std::string server_ip = "127.0.0.1";
    std::string message = "Hello, Server!";

    // 创建promise和future
    std::promise<std::string> promise;
    std::future<std::string> future = promise.get_future();

    // 启动异步任务
    std::thread([&promise, &server_ip, &message]() {
        try {
            std::string response = async_send_receive(server_ip, message);
            promise.set_value(response);
        } catch (const std::exception& e) {
            promise.set_exception(std::current_exception());
        }
    }).detach();

    // 等待并获取结果，设置超时时间为5秒
    if (future.wait_for(std::chrono::seconds(5)) == std::future_status::ready) {
        try {
            std::string response = future.get();
            std::cout << "Received response: " << response << std::endl;
        } catch (const std::exception& e) {
            std::cerr << "Error: " << e.what() << std::endl;
        }
    } else {
        std::cerr << "Request timed out" << std::endl;
    }

    return 0;
}

在这个示例中，我们使用std::future::wait_for方法设置了一个超时时间为5秒。如果在5秒内没有收到响应，程序将输出“Request timed out”。

总结

通过本文，我们详细介绍了如何使用C++11的std::future和std::promise实现异步网络通信。我们探讨了std::future和std::promise的基本概念、实现异步TCP客户端的具体步骤和代码，并展示了如何实现超时机制。

理解和掌握这些技术可以帮助你在异步编程和网络编程领域取得更大的进步。希望这篇文章能帮助你更好地理解和应用std::future和std::promise。如果你有任何问题或需要进一步的帮助，请随时联系我。Happy coding!

清水白石008
关注
专栏目录
C++异步通信使用什么技术或者函数或者库
weixin_42593701的博客
02-15 179
在C语言中，异步通信可以使用以下技术、函数或库来实现： 基于事件驱动的IO复用技术，如select、poll、epoll等，可以实现异步IO操作，这些函数在进行IO操作时不会阻塞进程，从而提高了程序的并发性能。 POSIX标准中提供的异步IO库，如aio_read、aio_write等函数，可以在后台异步执行IO操作，不需要阻塞进程，但使用时需要注意一些细节。 libuv库是一个跨平台的异步...
C++多线程_std::future与std::promise
惊鸿一博
01-23 1742
在并发编程中，我们通常会用到一组非阻塞的模型：promise\future。在python、js、java中都提供future\promise，是现代语言常用的非阻塞编程模型。
C++11中std::future的使用
网络资源是无限的
01-30 2万+
C++11中的std::future是一个模板类。std::future提供了一种用于访问异步操作结果的机制。std::future所引用的共享状态不能与任何其它异步返回的对象共享(与std::shared_future相反)( std::future references shared state that is not shared with any other asynchronous re...
C++11中std::shared_future的使用
网络资源是无限的
01-30 1万+
C++11中的std::shared_future是个模板类。与std::future类似，std::shared_future提供了一种访问异步操作结果的机制；不同于std::future，std::shared_future允许多个线程等待同一个共享状态；不同于std::future仅支持移动操作，std::shared_future既支持移动操作也支持拷贝操作，而且多个shared_futu...
std::future和std::promise
weixin_47326789的博客
08-30 840
C++11标准库提供了std::future和std::promise用于处理异步任务。std::future表示期望值，可以使用期望值等待一次性事件。std::promise表示承诺的意思，std::future可以和std::promise进行绑定。std::promise<T>提供设定值的方式(类型为T)，这个类型和std::future<T>对象相关联，期望值可以阻塞等待线程，同时，提供数据的线程可以使用组合中的承诺值来对相关值进行设置，并且将期望值的状态设置为就绪状态。
C++11使用std::future和std::promise实现线程同步和异步通信
prerfect_cat的博客
07-04 374
std::future：用于获取异步操作的结果，可以阻塞直到结果可用（eg:std::future.get()方法）。std::promise：用于设置异步操作的结果，通常与 std::future 一起使用。std::async：提供了一种简单的方式来启动异步任务并返回一个 std::future，用于获取任务结果。通过使用 std::future 和 std::promise，可以方便地在不同线程之间进行同步和数据传递，简化了异步编程的复杂性。
C++多线程系列——std::future | std::promise
weixin_42877425的博客
04-18 827
在 C++ 11 之前，想要从线程返回执行任务的结果，可以通过指针来完成。可以看到，要通过指针来传递结果，在操作上比较复杂需要涉及到mutex，且逻辑上没有那么舒服。因此 C++ 提供了类模板。
C++库std::future
qq_41898196的博客
03-24 8374
是C++11标准库（并发支持库）中的一个模板类，它表示一个异步操作的结果。当我们在多线程编程中使用异步任务时，可以帮助我们在需要的时候获取任务的执行结果。的一个重要特性是能够阻塞当前线程，直到异步操作完成，从而确保我们在获取结果时不会遇到未完成的操作。
C++11中的异步操作｜std::future｜std::promise｜std::packaged_task
后端开发为主+人工智能
07-22 976
C++11中的异步操作
C++11 多线程（std::thread）详解
热门推荐
jcShan709的博客
07-17 11万+
注：此教程以 Visual Studio 2019 Version 16.10.3 （MSVC 19.29.30038.1) 为标准 文章目录线程？进程？多线程？什么是多线程？进程与线程的区别C++11的std::threadstd::thread常用成员函数构造&析构函数常用成员函数举个栗子例一：thread的基本使用例二：thread执行有参数的函数例三：thread执行带有引用参数的函数注意事项（剩下的内容还没写完，明天再更） 线程？进程？多线程？ 什么是多线程？ 百度百科中的解释： 多.
C++11 <future>中std::promise 介绍
08-25
std::promise 是 C++11 <future> 头文件中的一个类，提供了一种异步提供值的方式。std::promise 对象可以保存某一类型 T 的值，该值可被 future 对象读取（可能在另外一个线程中），因此 std::promise 也提供了一种...
C++11中std::future的具体使用方法
08-25
C++11中std::future的具体使用方法 std::future是一个模板类，提供了一种用于访问异步操作结果的机制。std::future所引用的共享状态不能与任何其它异步返回的对象共享。一个future是一个对象，它可以从某个提供者的...
C++11多线程之std::future、std::promise、std::packaged_task的初步使用
十三阿哥的博客
08-11 262
【代码】C++11多线程之std::future、std::promise、std::packaged_task的初步使用。
c_cpp_properties.json文件的作用
程序员黄老师的精品课！
10-10 228
IntelliSense 是 VS Code 中内置的一个有用工具，它提供各种代码编辑功能，可帮助您更快、更高效地编写代码。例如，代码完成、参数信息、语法突出显示、代码操作（灯泡）和成员列表都是使用 IntelliSense 生成的。IntelliSense 配置存储在文件中，该文件在您的工作区中自动创建。如何产生 c_cpp_properties.json文件？这里配置一下头文件，就可以自动提示了，以OpenCV为例子。其中的属性可以在界面上改,文件会自动同步。
PyQt 的Tree Widget中拖放和点击的异常行为
weixin_44617651的博客
10-10 462
在 PyQt 的 ​​QTreeWidget​​ 中，如果你遇到 拖放 和 点击 的异常行为，可能是由于信号处理、事件拦截、拖放设置或树结构配置等问题导致的。以下是一些可能的常见问题和解决方案。
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 985
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
C++的随机数操作
最新发布
lch_001的博客
10-13 110
如果不引入种子，它的随机数不是随机数，是固定的一串数字。首先想到的肯定是rand()函数，但是这个有点问题。srand()函数，产生随机的种子。引入头文件<stdlib.h>产生0-99的随机数。
windows C++-创建数据流代理(三)
苏洛的博客
10-08 325
控制流指的是程序中操作的执行顺序。 控制流是通过使用条件语句、循环等控制结构调节的。 此外，数据流指的是一种编程模型，在这种模型中，只有当所有需要的数据都可用时，才会进行计算。 数据流编程模型与消息传递这一概念相关，其中程序的独立组件通过发送消息相互通信。 异步代理同时支持控制流和数据流编程模型。 尽管控制流模型适用于许多情况，但数据流模型也适用于其他一些情况，例如，当代理接收数据并执行基于该数据的有效负载的操作时。
cpp11的std::future和std::promise
03-27
std::future和std::promise是C++11中引入的线程库组件，它们可以用于在多线程编程中实现异步操作。 std::future是一种特殊的对象，用于表示异步操作的结果。可以通过std::async函数或std::promise对象的get_future()方法创建std::future对象。当异步操作完成时，使用std::future对象的get()方法可以获取异步操作的结果。 std::promise是一种特殊的对象，用于在一个线程中设置异步操作的结果，并在另一个线程中获取结果。可以通过std::promise的构造函数创建一个std::promise对象，并使用其get_future()方法获取一个std::future对象。在另一个线程中，可以通过std::future对象的get()方法获取异步操作的结果。 通过std::promise和std::future的配合使用，可以实现线程之间的通信和同步，从而实现复杂的多线程编程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

清水白石008

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值