Question

我无法在c ++ 11中找到正确的异步线程用法。我想要做的是我想要spwan线程，每个线程将同时运行，而不必像thread.join（）一样等待彼此这使得其他线程等到当前线程完成。所以，c ++中是否有任何库让线程并行运行而不必等待另一个完成。实际上我想要的是我想要的东西同时运行每个线程，以便它们不会等待另一个线程完成，并且它的功能可以同时执行，而不必等待其他线程完成。谢谢， Kushal

编辑：编辑::我发布下面的代码

#include <signal.h>
#include <thread>
#include <algorithm>
#include <cstring>
#include <csignal>
#include "paho_client.h"
using namespace std;
vector<string>    topic_container{"rpi2/temp","sense                          /bannana","sense/util","mqtt/temp","sense/temp","sense/pine","sense/fortis/udap"};
 vector<paho_client> publisher;
 vector<paho_client> subscriber;
 int finish_thread=1;
 void Onfinish(int signum){
 finish_thread=0;
 exit(EXIT_FAILURE);
 }

 int main(int argc, char** argv) {
 signal(SIGINT, Onfinish);
 int topic_index;
 if(argc<3){
    cout<<"the format of starting commandline argument is"<<endl;              
    exit(1);
    }

    while(finish_thread!=0){
    //paho_client::get_library_handle();
    if(strcmp(argv[1],"create_publisher")){
        for(topic_index=0;topic_index<atoi(argv[2]);topic_index++){
            thread pub_th;
            pub_th = thread([ = ]() {
                paho_client client("publisher", "192.168.0.102", "9876",
                                   topic_container[topic_index].c_str());
                client.paho_connect_withpub();
              publisher.push_back(client);
            });
         pub_th.join();
        }
        vector<paho_client>::iterator it;
        int publisher_traverse=0;
        for(it=publisher.begin();it<publisher.end();publisher_traverse++){
           publisher[publisher_traverse].increment_count();
          publisher[publisher_traverse].get_count();
       }

   }
  }
 return 0;
}

在使用异步后，我将获得与上述相同的行为，请指出我在哪里出错

 #include <signal.h>
 #include <thread>
 #include <algorithm>
 #include <cstring>
#include <csignal>
#include <future>
#include "paho_client.h"
using namespace std;
vector<string> topic_container{"rpi2/temp","sense/apple","sense/bannana","sense/util","mqtt/temp","sense/temp","sense/pine","sense/fortis/udap"};
vector<paho_client> publisher;
vector<paho_client> subscriber;
int finish_thread=1;
void Onfinish(int signum){
finish_thread=0;
exit(EXIT_FAILURE);
}
int accumulate_block_worker_ret(int topic_index) {
//int topic_index=0;
paho_client client("publisher", "192.168.0.102", "9876",
                   topic_container[topic_index].c_str());
client.paho_connect_withpub();
publisher.push_back(client);
client.increment_count();
return client.get_count();
 }


    int main(int argc, char** argv) {
    signal(SIGINT, Onfinish);

    if(argc<3){
    cout<<"the format of starting commandline argument is . /paho_client_emulate <create_publisher><count of publisher client to spawn>"  <<endl;
    exit(1);
   }

     while(finish_thread!=0){
//   paho_client::get_library_handle();
     int topic_index;
      if(strcmp(argv[1],"create_publisher")){
     for(topic_index=0;topic_index<atoi(argv[2]);topic_index++){
    //  thread pub_th;
    // pub_th = thread([ = ]() {
       future<int> f =  async(std::launch::async,accumulate_block_worker_ret,topic_index);
    //      });
    //  pub_th.join();
        cout<<"the returned value from future is"<<f.get()<<endl;
       }

    vector<paho_client>::iterator it;
    int publisher_traverse=0;
    for(it=publisher.begin();it<=publisher.end();publisher_traverse++){
        cout<<"came here"<<endl;
        publisher[publisher_traverse].increment_count();
        publisher[publisher_traverse].get_count();
     }

     }
     }
     return 0;
    }

Answer 1

我想首先启动所有发布者客户端（作为线程）和稍后从每个线程发布消息

pub_th.join()在启动线程的循环中放错位置，因此在开始下一个线程之前等待每个线程的终止。要让线程并行运行，只需将.join()移到该循环外部即可。当然要在循环体之后访问线程，它们必须存储在某个地方，例如。 G。在vector中 - 为此，将第一个for循环更改为

        vector <thread> pub_threads;
        for (topic_index=0; topic_index<atoi(argv[2]); topic_index++)
        {
            pub_threads.push_back(thread([ = ]() { /* whatever */ }));
        }

以后完成：

        for (auto &th: pub_threads) th.join();

实际上我在每个实例中运行无限 paho_client所以第一个线程没有完成...... 该线程不断运行

当然，如果从未做过，那么.join()就没有意义了。

在c ++中实现异步线程

1 个答案: