c++ 异步多线程实例

下面是一个简单的 C++ 异步多线程实例：

#include <iostream>
#include <thread>
#include <future>

using namespace std;

int factorial(int n) {
    int res = 1;
    for (int i = n; i > 1; --i) {
        res *= i;
    }
    return res;
}

int main() {
    int x = 5;

    // 异步执行阶乘计算
    future<int> fut = async(factorial, x);

    cout << "正在计算 " << x << " 的阶乘..." << endl;

    // 执行其他任务
    this_thread::sleep_for(chrono::milliseconds(1000));

    // 获取异步计算结果
    int result = fut.get();

    cout << x << " 的阶乘是 " << result << endl;

    return 0;
}

在这个例子中，`factorial()` 函数计算一个整数的阶乘。`async()` 函数将该函数异步执行，并返回一个 `future` 对象，该对象可以用于获取异步计算的结果。在主线程中，我们可以执行其他任务，然后调用 `get()` 函数获取异步计算结果。

相关问题

c++17 线程 异步示例

### C++17 中 `std::thread` 和 `std::async` 的示例代码

在现代C++中，`std::thread` 和 `std::async` 是处理并发和并行任务的重要工具。下面展示如何使用这两个特性来创建多线程应用程序。

#### 使用 `std::thread`

通过 `std::thread` 可以显式地启动新线程：

#include <iostream>
#include <thread>

void print_thread_id(int id) {
    std::cout << "Thread ID, " << id << ", this_thread::get_id() = "
              << std::this_thread::get_id() << '\n';
}

int main() {
    std::thread t(print_thread_id, 0);
    print_thread_id(1);

    if (t.joinable()) {
        t.join();
    }
}

这段程序展示了两个不同的线程分别打印各自的ID[^1]。

#### 使用 `std::async`

对于更复杂的场景，可以利用 `std::async` 来简化异步调用逻辑，并自动管理底层线程池资源：

#include <future>
#include <chrono>
#include <iostream>

// 定义一个耗时的任务函数
double calculate_pi_approximation(long iterations) {
    double pi{0};
    for (long i=0; i<iterations; ++i){
        pi += 4.0 * ((i%2==0)? 1 : -1)/(2*i + 1); 
    }
    return pi;
}

int main(){
    auto start_time = std::chrono::steady_clock::now();

    // 启动异步计算PI近似值
    std::future<double> result_future = std::async(std::launch::async,
                                                   calculate_pi_approximation,
                                                   100000L);

    // 主线程继续做其他工作...
    std::cout << "Waiting for PI calculation...\n";

    // 获取最终结果
    double pi_result = result_future.get(); 

    auto end_time = std::chrono::steady_clock::now();
    std::chrono::duration<double> elapsed_seconds = end_time-start_time;

    std::cout << "Approximated value of Pi is: " << pi_result << "\n";
    std::cout << "Time taken by function: " << elapsed_seconds.count() << "s\n";
    
    return 0;
}

此例子说明了当主线程等待来自子线程的结果时不会阻塞整个进程，而是可以在后台完成任务的同时执行其它操作[^3]。

需要注意的是，在某些情况下如果编译器优化级别较高可能会导致 `std::async` 行为不符合预期，比如看起来像是同步运行而不是真正开启新的线程[^2]。因此建议开发者们仔细阅读文档以及测试不同环境下的表现。

qt c++ qxlsx 多线程保存数据

在Qt和C++中，结合QXXLS库（用于读写Excel文件）处理大数据并利用多线程可以提高程序性能。以下是使用QThread进行多线程保存数据的基本步骤：

1. 引入必要的库和头文件：

#include <QObject>
#include <QThread>
#include <QFuture>
#include <QSettings>
#include <QWorkbook>
#include <QWorksheet>

2. 创建一个单独的Worker类，用于处理数据保存操作：

class ExcelWriter : public QObject {
    Q_OBJECT
public:
    explicit ExcelWriter(QObject *parent = nullptr) : QObject(parent) {}
    QFuture<void> writeDataToSheet(const QString& sheetName, const QVector<QString>& data);
private slots:
    void run();
};

在这个类里，`writeDataToSheet`方法负责实际的数据写入操作，并通过`run()`槽函数在新线程中执行。

3. 实现`writeDataToSheet`方法：

QFuture<void> ExcelWriter::writeDataToSheet(const QString &sheetName, const QVector<QString>& data) {
    QThreadPool *pool = QThreadPool::globalInstance();
    auto future = pool->start([this, sheetName, data]() {
        // 创建工作簿和工作表
        QWorkbook workbook;
        QWorksheet *worksheet = workbook.addWorksheet(sheetName);

        // 写入数据...
        // 使用QXXLS提供的API
        for (const QString &row : data) {
            // ...这里写入行数据到单元格
        }

        // 保存工作簿
        workbook.save("your_excel_file.xlsx");
    });

    return future;
}

4. 在主线程中调用并管理多线程：

void MainWindow::saveDataInParallel(const QVector<QString>& data) {
    ExcelWriter writer(this);
    auto saveTask = writer.writeDataToSheet("Sheet1", data);
    connect(&writer, &ExcelWriter::finished, this, []() { qDebug() << "Save operation finished"; });
    saveTask.waitForFinished(); // 等待任务完成
}

5. 当需要保存大量数据时，创建多个ExcelWriter实例并异步执行它们，以充分利用多核处理器。