如何检查线程的“共享状态”或“内存状态”的详细状态？如何不调用std：：async（ ）块？

问：

我使用多线程的方法是：

typedef std::pair<std::vector<char>, int> PATH_PAIR;

std::list<PATH_PAIR>
TSP::return_all_paths_list(
    PATH_PAIR                                       parent_path_pair,
    std::list<char>                                 unvisited_cities
) {
    std::list<PATH_PAIR>                            subseq_paths_list;
    std::vector<std::future<std::list<PATH_PAIR>>>  future_vec;
   
    if (unvisited_cities.empty()) { // END RECURSION
        // NON-REALTED CODE
        return subseq_paths_list;
    }

    for (const char curr_city: unvisited_cities) {   // DO RECURSION
        PATH_PAIR                           new_path_pair_addr = parent_path_pair;
        std::list<char>                     subseq_unvisited_cities = unvisited_cities;
        std::future<std::list<PATH_PAIR>>   returned_path_list_future;
        // NON-RELATED CODE
        returned_path_list_future = std::move(std::async(std::launch::async, return_all_paths_list, this, new_path_pair_addr, subseq_unvisited_cities));

        future_vec.push_back(returned_path_list_future);
    }

    while (!future_vec.empty()) {   // GET-VALUES-WHILE
        for (std::future<std::list<PATH_PAIR>>& curr_future : future_vec)  // GET-VALUES-FOR
            if (curr_future.valid()) {
                subseq_paths_list.merge(curr_future.get());
            }
        // future_list.remove_if(
        //     [] (std::future<std::list<PATH_PAIR>> input_future) -> bool {
        //         return !input_future.valid();
        //     }
        // );
    }

    return subseq_paths_list;
}

我有几个问题：

1. 根据 cppreference std：：async：

   如果从 std：：async 获取的 std：：future 未从引用中移动或绑定到引用，则 std：：future 的析构函数将在完整表达式的末尾阻塞，直到异步操作完成，实质上使代码（如以下代码）同步：

   std::async(std::launch::async, []{ f(); }); // temporary's dtor waits for f()
   std::async(std::launch::async, []{ g(); }); // does not start until f() completes
   

   a. “移自”和“绑定到参考”这两个词是什么意思？
   b. 将调用包装在 an 中是否会使调用在循环的后续迭代中不阻塞？
   c. 或者上述两行中的调用是否仅仅因为使用了 lambda 而阻塞？std::asyncstd::movestd::async// DO RECURSION

2. 如何检查共享状态是否已准备就绪？
   a.a. 对 （和 ） 的调用会阻止，直到共享状态准备就绪。问题是，我不想等待。我想检查共享状态是否已准备就绪，如果没有，我想继续下一个对象。我该怎么做？ 仅检查共享状态是否与对象关联。
   b. 此外，根据 cppreference std：：async，调用的返回值为：std::future::waitstd::future::getstd::futurestd::future::validstd::async

   std：：future 是指此调用创建的共享状态std::async

   因此，在循环中，如果对它进行调用，则获取的将始终返回（前提是尚未对它进行调用）。如果我在调用 an 后删除，则不必检查对象的有效性。但是，我尝试过的删除元素 STL 方法都不起作用，编译时错误大约是显示器高度的两倍。//GET VALUESstd::futuretruestd::future::validstd::future::getstd::futurestd::future::getstd::future

   我想，也许调用除了释放共享状态之外还会破坏对象，但是我写了一段小测试代码：std::future::get

   int mul2(int x) {return x << 1; }
   int main() {
       std::vector<std::future<int>> fut_vec;
       for (int i = 0; i < 5; i++) {
           fut_vec.push_back(std::move(std::async(std::launch::async, mul2, i)));
       }
       for (std::vector<std::future<int>>::iterator itr = fut_vec.begin(); itr != fut_vec.end(); itr++) {
           if (itr->valid()) {
               std::cout << "Value: " << itr->get() << " | No. of vec elements(futures): " << fut_vec.size() << std::endl;
           }
       }
   
       return 0;
   }
   

   显示 总是返回相同的整数。fut_vec.size()

   如何销毁对象？std::future

我最近开始接触多线程，所以现在我正在尝试使用多线程来实现旅行推销员问题。