如何实现C++多线程运行函数并仅返回首个成功结果

现有C++函数theGoodString用于生成符合条件的字符串，当前的并行运行代码会让所有线程完成计算并输出结果，但需求改为：启动指定数量的线程运行该函数，仅返回第一个成功得到的结果，同时让其他线程尽早停止无用计算。

原核心函数：

string theGoodString(string someString) {
     string goodString;
     bool criteriaMet = false;
     while (!criteriaMet) {
           goodString = processString(someString);
          // some criteria
           criteriaMet = true;
     }
     return goodString;
}

原并行代码：

void runTheGoodString(int numThread, const string& someString){
    cout << "Thread " << numThread << " starting" << endl;
    string goodString = theGoodString(someString);
    cout << "Thread " << numThread << " finished with result: " << goodString << endl;
}

void runTheGoodStringParallel(const string& someString, int numThreads) {
    vector<thread> threads;
    for (int i = 0; i < numThreads; ++i) {
        threads.emplace_back(runTheGoodString, i, someString);
    }
    for (thread& thread : threads) {
        thread.join();
    }
}

要实现“取第一个结果并终止其他线程”，需要线程安全的结果共享和终止通知机制，具体调整如下：

1. 添加线程安全共享状态：用std::atomic<bool>标记是否已找到结果，用std::mutex保护结果字符串的写入，避免竞争。
2. 让theGoodString支持提前终止：在循环中加入终止信号检查，一旦发现已有结果就立即退出，减少无用计算。
3. 调整线程函数逻辑：线程启动先检查终止信号，若已有结果直接退出；完成计算后尝试写入结果，仅第一个成功写入的有效。
4. 主线程处理结果：等待所有线程收尾（无论是否提前退出），最终返回第一个得到的结果。

#include <iostream>
#include <vector>
#include <thread>
#include <atomic>
#include <mutex>
#include <optional>

// 假设processString是已实现的业务函数
string processString(const string& s) {
    // 保留原有业务逻辑
    return s;
}

// 修改后的theGoodString，支持响应终止信号
string theGoodString(string someString, std::atomic<bool>& stopSignal) {
     string goodString;
     bool criteriaMet = false;
     // 循环中检查终止信号，避免无用计算
     while (!criteriaMet && !stopSignal.load(std::memory_order_acquire)) {
           goodString = processString(someString);
          // some criteria
           criteriaMet = true;
     }
     return goodString;
}

// 线程函数：完成计算后尝试写入结果，仅第一个有效
void runTheGoodString(int numThread, const string& someString,
                      std::atomic<bool>& stopSignal, std::mutex& resultMutex,
                      std::optional<string>& finalResult) {
    cout << "Thread " << numThread << " starting" << endl;

    // 先检查是否已有结果，避免白跑
    if (stopSignal.load(std::memory_order_acquire)) {
        cout << "Thread " << numThread << " exiting early: result already found" << endl;
        return;
    }

    string goodString = theGoodString(someString, stopSignal);

    // 如果计算过程中收到终止信号，直接退出
    if (stopSignal.load(std::memory_order_acquire)) {
        cout << "Thread " << numThread << " exiting early: stop signal received" << endl;
        return;
    }

    // 尝试写入结果，只有第一个线程能成功设置
    std::lock_guard<std::mutex> lock(resultMutex);
    if (!finalResult.has_value()) {
        finalResult = std::move(goodString);
        stopSignal.store(true, std::memory_order_release);
        cout << "Thread " << numThread << " found the first result: " << *finalResult << endl;
    } else {
        cout << "Thread " << numThread << " finished but result already exists" << endl;
    }
}

// 并行运行函数，返回第一个得到的结果
std::optional<string> runTheGoodStringParallel(const string& someString, int numThreads) {
    std::atomic<bool> stopSignal(false);
    std::mutex resultMutex;
    std::optional<string> finalResult;
    std::vector<std::thread> threads;

    for (int i = 0; i < numThreads; ++i) {
        threads.emplace_back(runTheGoodString, i, std::ref(someString),
                             std::ref(stopSignal), std::ref(resultMutex),
                             std::ref(finalResult));
    }

    // 等待所有线程完成收尾
    for (auto& t : threads) {
        if (t.joinable()) {
            t.join();
        }
    }

    return finalResult;
}

// 使用示例
int main() {
    auto result = runTheGoodStringParallel("test_input", 4);
    if (result.has_value()) {
        cout << "Final result: " << *result << endl;
    } else {
        cout << "No result found" << endl;
    }
    return 0;
}

• std::atomic<bool> stopSignal：用原子操作实现线程安全的终止通知，避免数据竞争。
• std::optional<string> finalResult：用于存储第一个有效结果，通过has_value()判断是否获取到结果。
• std::lock_guard<std::mutex>：保护结果的写入操作，确保只有第一个完成计算的线程能设置最终结果。
• theGoodString中的终止检查：在循环中加入终止信号判断，让线程能及时响应停止指令，减少不必要的计算开销。

内容的提问来源于stack exchange，提问作者cnoob179