C++多线程编程进阶

在我们之前的文章中，我们已经介绍了C++多线程编程的基础知识，包括如何创建线程，如何使用互斥量进行同步，以及如何使用条件变量进行线程间通信。在这篇文章中，我们将深入探讨一些更高级的主题，包括线程池，future和promise，以及atomic操作。

一、线程池

线程池是一种创建和管理线程的技术，它预先创建一定数量的线程，并根据需要将任务分配给这些线程。线程池可以减少线程创建和销毁的开销，提高系统的响应速度。

C++标准库并没有提供线程池，但我们可以使用`std::thread`和`std::queue`来自己实现一个简单的线程池：

```cpp
#include <vector>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>

class ThreadPool {
public:
    ThreadPool(size_t num_threads) {
        for (size_t i = 0; i < num_threads; ++i) {
            workers.emplace_back([this] {
                for (;;) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(this->queue_mutex);
                        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();
                }
            });
        }
    }

    template<class F, class... Args>
    auto enqueue(F&& f, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type> {
        using return_type = typename std::result_of<F(Args...)>::type;
        auto task = std::make_shared<std::packaged_task<return_type()>>(std::bind(std::forward<F>(f), std::forward<Args>(args)...));
        std::future<return_type> res = task->get_future();
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            if(stop)
                throw std::runtime_error("enqueue on stopped ThreadPool");
            tasks.emplace([task]() { (*task)(); });
        }
        condition.notify_one();
        return res;
    }

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

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop = false;
};
```

这个线程池的使用方法如下：

```cpp
ThreadPool pool(4);
std::vector<std::future<int>> results;

for(int i = 0; i < 8; ++i) {
    results.emplace_back(
        pool.enqueue([i] {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            return i*i;
        })
    );
}

for(auto && result: results)
    std::cout << result.get() << ' ';
std::cout << std::endl;
```

 二、Future和Promise

C++提供了`std::future`和`std::promise`两个类，用于表示异步操作的结果。`std::future`是一个持有共享状态的对象，这个共享状态可以被`std::promise`对象设置，也可以通过`std::future::get()`获取。`std::promise`和`std::future`通常成对使用，以实现线程间的同步。

以下是一个使用`std::promise`和`std::future`的例子：

```cpp
#include <iostream>
#include <thread>
#include <future>

void print_int(std::future<int>& fut) {
    int x = fut.get();
    std::cout << "value: " << x << '\n';
}

int main() {
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();
    std::thread t(print_int, std::ref(fut));
    prom.set_value(10);
    t.join();
    return 0;
}
```

在这个例子中，我们创建了一个新的线程`t`，这个线程等待`fut.get()`返回。主线程通过`prom.set_value(10)`设置共享状态，这将使得`fut.get()`返回。

三、原子操作

C++提供了`std::atomic`模板类，用于表示一个可以进行原子操作的对象。原子操作是一种特殊的操作，它是不可中断的，即在进行原子操作的过程中，不会被其他线程打断。这使得我们可以在不使用互斥量的情况下进行同步。

以下是一个使用`std::atomic`的例子：

```cpp
#include <iostream>
#include <atomic>
#include <thread>

std::atomic<int> counter(0);

void increment() {
    for (int i = 0; i < 1000000; ++i) {
        ++counter;
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    std::cout << "counter: " << counter << '\n';
    return 0;
}
```

在这个例子中，我们创建了两个线程，这两个线程同时对`counter`进行增加操作。由于`counter`是一个`std::atomic<int>`对象，所以这些操作是原子的，不会发生数据竞争。

结语

C++多线程编程是一个深入的话题，需要对操作系统和计算机系统有一定的了解。在实际编程中，我们需要注意线程安全、数据竞争、死锁等问题。希望这篇文章能帮助你更深入地理解C++多线程编程。