c++ - 您如何在 C++ 中正确地等待/等待异步？

Question

抱歉，如果问题不清楚。我会试着在这里解释一下。

我正在做一个测试项目，其中两个节点将相互通信特殊数据包。如：节点 A 将向节点 B 发送一个数据包，当节点 B 生成它的数据包时，节点 B 也应该处理来自节点 A 的信息。节点 A 应该为节点 B 准备另一个数据包。

我一直在阅读 std::future 但我不确定我是否理解它是如何工作的。我的问题是关于大部分注释掉的代码。这只是伪代码，因此我可以尝试更好地了解 C++ 中的异步函数。我通常用 C#/Java 编程，其中异步函数相当简单（ish）。我希望上述解释我正在尝试做的事情。

下面的代码可能还有其他一些错误。这只是一个快速而肮脏的尝试，试图传达我的要求。

我的问题是：

1. 假设节点 B 是这个理论应用程序的一个单独实例，在不同的设备上运行，那么检查节点 B 是否准备就绪的最佳方法是什么？如果这有什么不同，这是用 Linux C++ 编写的。

2. 这甚至是在 C++ 中执行 Tasks/Await/Await Async 的正确方法吗？如果这是不正确的，那么正确的方法是什么？

提前致谢。

//Excerpt from pseudo code. file would be kw_worker_delegate.h

#include <future>
#include <iostream>
#include <string>
#include <optional>
#include <system_error>

#include "kw_network.h"

class kw_worker
{
private:
   /* ... */
   std::future<kw_packet> *kw_packet_receive_delegate;
   std::future<bool> *kw_packet_send_delegate;
   
   bool worker_is_ready;
   
   std::string kw_worker_adress;
    
   network_interface *kw_network_interface;

   /* Base CTOR that provides Delegates */
public:
   kw_worker(std::future<kw_packet> *kwpktr, std::future<kw_packet> *kwpkts, network_interface *kwinetf, std::string kwaddr);

   bool kw_worker_execute(bool isSendOrRecieve, kw_worker *active_worker, kw_worker *target_worker, std::optional<kw_packet> packet_data = std::nullopt);
};

kw_worker::kw_worker(std::future<kw_packet> *kwpktr, std::future<bool> *kwpkts, network_interface *kwinetf, std::string kwaddr)
{
   &kw_packet_recieve_delegate = &kwpktr;
   &kw_packet_send_delegate = &kwpkts;
   &kw_network_interface = &kwintef;
   kw_worker_address = kwaddr;
   kw_worker_is_ready = true;
}

bool kw_Worker::kw_worker_execute(bool isSendOrRecieve, kw_worker *active_worker, kw_worker *target_worker, std::optional<kw_packet> packet_data = std::nullopt);
{
   try
   {
    //if(isSendOrRecieve)
    //{
    //    IS THIS CORRECT?
    //
    //   if(!(&target_worker->worker_is_ready))
    //   {
    //      cout << "Worker B is not ready for a data submission...\n";
    //      do_something_or_await();
    //   }else{ 
    //      if(packet_data.has_value())
    //         kw_packet_send_delegate = std::async (&kw_network_interface->send_to, &target_worker->kw_worker_adress, packet_data);
    //      else throw -1;
    //      cout << "The data was sent to Worker B. Waiting for response on receipt of data...\n";
    //      &active_worker->worker_is_ready = true;
    //
    //      //Do somewithng else...
    //   }
    //}else{
    //   if(!(&active_worker->worker_is_ready))
    //   {
    //      cout << "Worker A is not ready to receive data...\n";
    //      do_something_or_await();
    //   }else{ 
    //      kw_packet_receive_delegate = std::async (&kw_network_interface->receive_from, &target_worker->kw_worker_adress);
    //      cout << "The data was received by Worker A. A Will now process the data...\n";
    //  &active_worker->kw_worker_is_ready = false;
    //   
    //      //Worker B will set it's worker_is_ready boolean value using it's send function
    //   
    //      //process the data now
    //   }
    //}
    }catch(const system_error &e)
    {
        cout << "There are no threads available to complete delegation. Please Try Again later";
        return false;
    }
    catch(int)
    {
        cout << "Some other error occurred when getting data from worker" << &target_worker << ". Please Try Again later.";
        return false;
    }
    return true;
}

标签： c++c++11asynchronousasync-awaitstd-future