c++多线程异步等优化例子

• 在C++中，多线程和异步编程是优化程序性能的重要手段。以下是一些常见的优化例子，展示了如何使用多线程和异步编程来提高性能。

1. 使用std::async进行异步计算
   std::async 是一个便捷的方式，可以让某个函数在后台线程中执行，而主线程可以继续执行其他任务。

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

// 模拟一个计算密集型的函数
int compute(int x) {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return x * x;
}

int main() {
    // 异步调用compute函数
    std::future<int> result = std::async(std::launch::async, compute, 10);

    // 主线程可以继续做其他事情
    std::cout << "Doing other work..." << std::endl;

    // 等待异步结果
    int value = result.get();
    std::cout << "Result: " << value << std::endl;

    return 0;
}

2. 使用std::thread进行并行任务处理
   在处理多个任务时，可以使用std::thread来实现并行化，从而提高程序的吞吐量。

#include <iostream>
#include <thread>
#include <vector>

// 模拟一个长时间运行的任务
void task(int id) {
    std::cout << "Task " << id << " started" << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::cout << "Task " << id << " finished" << std::endl;
}

int main() {
    std::vector<std::thread> threads;

    // 创建多个线程来执行任务
    for (int i = 0; i < 5; ++i) {
        threads.emplace_back(task, i);
    }

    // 等待所有线程完成
    for (auto& th : threads) {
        th.join();
    }

    return 0;
}

3. 使用std::future和std::promise进行线程间通信
   std::future和std::promise可以让线程之间通过传递数据来进行通信，这对于协调线程间的任务非常有用。

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

// 线程执行的任务，等待主线程传递数据
void worker(std::promise<int>&& prom) {
    int value = prom.get_future().get(); // 从主线程接收数据
    std::cout << "Received value: " << value << std::endl;
}

int main() {
    std::promise<int> prom;

    // 启动一个线程
    std::thread t(worker, std::move(prom));

    // 模拟一些工作
    std::this_thread::sleep_for(std::chrono::seconds(1));

    // 向线程传递数据
    prom.set_value(42);

    // 等待线程完成
    t.join();

    return 0;
}

4. 使用std::mutex保护共享资源
   在多线程环境中访问共享资源时，需要使用互斥锁（std::mutex）来避免数据竞争。

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;
int shared_data = 0;

void increment(int id) {
    for (int i = 0; i < 1000; ++i) {
        std::lock_guard<std::mutex> lock(mtx);
        ++shared_data;
    }
    std::cout << "Thread " << id << " finished." << std::endl;
}

int main() {
    std::thread t1(increment, 1);
    std::thread t2(increment, 2);

    t1.join();
    t2.join();

    std::cout << "Final shared data: " << shared_data << std::endl;
    return 0;
}

5. 使用线程池提高任务管理效率
   线程池是一种优化策略，可以避免频繁创建和销毁线程的开销，适合处理大量短时间任务的场景。

#include <iostream>
#include <vector>
#include <thread>
#include <queue>
#include <functional>
#include <future>
#include <mutex>
#include <condition_variable>

class ThreadPool {
public:
    ThreadPool(size_t numThreads);
    ~ThreadPool();

    template <class F, class... Args>
    auto enqueue(F&& f, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type>;

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;

    std::mutex queueMutex;
    std::condition_variable condition;
    bool stop;
};

ThreadPool::ThreadPool(size_t numThreads) : stop(false) {
    for (size_t i = 0; i < numThreads; ++i) {
        workers.emplace_back([this] {
            for (;;) {
                std::function<void()> task;
                {
                    std::unique_lock<std::mutex> lock(this->queueMutex);
                    this->condition.wait(lock, [this] { return this->stop || !this->tasks.empty(); });
                    if (this->stop && this->tasks.empty()) {
                        return;
                    }
                    task = std::move(this->tasks.front());
                    this->tasks.pop();
                }
                task();
            }
        });
    }
}

ThreadPool::~ThreadPool() {
    {
        std::unique_lock<std::mutex> lock(queueMutex);
        stop = true;
    }
    condition.notify_all();
    for (std::thread& worker : workers) {
        worker.join();
    }
}

template <class F, class... Args>
auto ThreadPool::enqueue(F&& f, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type> {
    using returnType = typename std::result_of<F(Args...)>::type;

    auto task = std::make_shared<std::packaged_task<returnType()>>(std::bind(std::forward<F>(f), std::forward<Args>(args)...));
    std::future<returnType> result = task->get_future();

    {
        std::unique_lock<std::mutex> lock(queueMutex);
        if (stop) {
            throw std::runtime_error("enqueue on stopped ThreadPool");
        }
        tasks.emplace([task]() { (*task)(); });
    }
    condition.notify_one();
    return result;
}

int main() {
    ThreadPool pool(4);

    auto result1 = pool.enqueue([](int a, int b) { return a + b; }, 2, 3);
    auto result2 = pool.enqueue([](int a, int b) { return a * b; }, 2, 3);

    std::cout << "Result 1: " << result1.get() << std::endl;
    std::cout << "Result 2: " << result2.get() << std::endl;

    return 0;
}

总结

• 这些例子展示了C++中多线程和异步编程的基本应用方式。通过合理使用这些技术，可以显著提升程序的执行效率和响应能力。根据具体的应用场景，选择合适的并发工具（如std::async、std::thread、std::future、线程池等）进行优化是关键。