详情：

在下面的程序中，多个threads(本例中为简单起见只有2个)监听从函数返回的相同的值66，遵循两个函数中产生结果66的一些逻辑。

threads使用async，66的值使用futures返回。使用while循环来尝试连续检查线程1和线程2的status，以检查它们中的任何一个是否已经完成，在这种情况下，然后从任何一个线程获取最快的结果并在某些计算中使用。

目标：

1.在两个threads中，检测其中哪一个最先返回66的值
1.只要一个线程返回66(不管另一个线程是否已经完成)，返回值就在main()中可用，以便对其执行一些进一步的简单运算
1.如果一个线程返回66，并对main()中的这个值执行算术运算，然后另一个线程随后也传递66，则不应在任何计算中使用第二个返回值

**请注意：**在决定发布这个问题之前，我们已经咨询了以下资源：

1.How to check if thread has finished work in C++11 and above?
1.Using Multithreading two threads return same value with different inputs?
1.后台加载的C++线程
1.Future returned by a function
1.Start multiple threads and wait only for one to finish to obtain results

问题和当前产出：

目前，即使function1中的代码速度慢得多(例如，function1中有1000次迭代的for循环和function1中有10次迭代的for循环)，程序始终输出第一个完成的thread是rf1。这让我相信，我可能引入了某种blocking行为？

节目尝试：

# include <future>

    #include <iostream>
    #include "unistd.h"

    double function1() {

        // Logic to retrieve _value
        // ...
        double _value = 66;

        return _value;
    }

    double function2() {
        // Logic to retrieve _value
        // ...
        double _value = 66;

        return _value;
    }

    int main() {

        double ret_value = 0;

        auto rf1 = std::async(std::launch::async, function1);
        auto status1 = rf1.wait_for(std::chrono::nanoseconds(1));

        auto rf2 = std::async(std::launch::async, function2);
        auto status2 = rf2.wait_for(std::chrono::nanoseconds(1));

        while (true) {

            if (status1 == std::future_status::ready) {
                std::cout << "RF1 FINISHED FIRST" << std::endl;

                // No longer need returned val from 2nd thread.
                // Get result from 1st thread
                ret_value = rf1.get();
                break;
            }
            else if (status2 == std::future_status::ready) {
                std::cout << "RF2 FINISHED FIRST" << std::endl;

                // No longer need returned val from 1st thread.
                // Get result from 2nd thread
                ret_value = rf2.get();
                break;
            }

            else if (status1 != std::future_status::ready) {

                // RF1 not finished yet
                status1 = rf1.wait_for(std::chrono::nanoseconds(1));
            }
            else if (status2 != std::future_status::ready) {

                // RF2 not finished yet
                status2 = rf2.wait_for(std::chrono::nanoseconds(1));
            }
        }

        // Do some calculations on the quickest
        // returned value
        double some_value = ret_value + 40;

        return 0;
    }

问题：

**Q1.**是否可以通过任何方式修改程序以检测返回最快的thread，以便在main()中使用66的返回值进行进一步计算？

q2.while循环是否引入了任何类型的blocking行为？

如果任何人能够提供建议或指出一些有助于解决这一困境的资源，我们将不胜感激。到目前为止，找到与此场景完全匹配的multithreading文档一直是一个挑战。

编辑：

根据@jxh提供的有用答案，指示WHILE循环继续等待的else if条件已被删除，如下所示。

此外，还向function1和function2添加了一些逻辑，以确定哪一个将最先完成。如代码中所示，function1具有98迭代，function2具有100迭代，但输出仍然显示function2已首先完成：

# include <future>

# include <iostream>

# include "unistd.h"

double function1() {

    // Logic to retrieve _value
    for (int i = 0; i < 98; i++) {
        std::cout << std::endl;
    }
    double _value = 66;

    return _value;
}

double function2() {

    // Logic to retrieve _value
    for (int i = 0; i < 100; i++) {
        std::cout << std::endl;
    }
    double _value = 66;

    return _value;
}

int main() {

    double ret_value = 0;

    auto rf1 = std::async(std::launch::async, function1);
    auto status1 = rf1.wait_for(std::chrono::nanoseconds(1));

    auto rf2 = std::async(std::launch::async, function2);
    auto status2 = rf2.wait_for(std::chrono::nanoseconds(1));

    while (true) {

        if (status1 == std::future_status::ready) {
            std::cout << "RF1 FINISHED FIRST" << std::endl;

            // No longer need returned val from 2nd thread.
            // Get result from 1st thread
            ret_value = rf1.get();
            break;
        }
        else if (status2 == std::future_status::ready) {
            std::cout << "RF2 FINISHED FIRST" << std::endl;

            // No longer need returned val from 1st thread.
            // Get result from 2nd thread
            ret_value = rf2.get();
            break;
        }

        status1 = rf1.wait_for(std::chrono::nanoseconds(1));
        status2 = rf2.wait_for(std::chrono::nanoseconds(1));

    }

    // Do some calculations on the quickest
    // returned value
    double some_value = ret_value + 40;

    return 0;
}