如何在Linux C++中编写可重用的多线程组件

在 Linux 中使用 C++ 编写可重用的多线程组件需要遵循以下步骤：

1. 包含头文件： 首先，确保包含了必要的头文件。对于多线程编程，你需要包含 <iostream>、<thread>、<mutex> 和 <vector>。

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

2. 定义互斥锁： 为了确保多线程组件中的数据在任何时候只被一个线程访问，需要使用互斥锁（std::mutex）。定义一个全局互斥锁对象，以便在多个线程之间共享。

std::mutex mtx;

3. 创建可重用的多线程函数： 编写一个封装了多线程逻辑的函数。这个函数将接受一个任务列表作为参数，并在单独的线程中执行每个任务。

void execute_tasks(const std::vector<std::function<void()>>& tasks) {
    for (const auto& task : tasks) {
        std::unique_lock<std::mutex> lock(mtx);
        task();
        lock.unlock();
    }
}

4. 创建线程池： 为了实现可重用的多线程组件，可以创建一个线程池类。这个类将负责管理线程的创建和销毁，以及任务的分配和执行。

class ThreadPool {
public:
    ThreadPool(size_t num_threads) {
        for (size_t i = 0; i < num_threads; ++i) {
            workers.emplace_back(&ThreadPool::worker_thread, this);
        }
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(mtx);
            stop = true;
        }
        cv.notify_all();
        for (auto& worker : workers) {
            if (worker.joinable()) {
                worker.join();
            }
        }
    }

    template <typename F, typename... Args>
    void enqueue(F&& task, Args&&... args) {
        {
            std::unique_lock<std::mutex> lock(mtx);
            tasks.emplace_back(std::bind(std::forward<F>(task), std::forward<Args>(args)...));
        }
        cv.notify_one();
    }

private:
    void worker_thread() {
        while (true) {
            std::function<void()> task;
            {
                std::unique_lock<std::mutex> lock(mtx);
                cv.wait(lock, [this] { return stop || !tasks.empty(); });
                if (stop && tasks.empty()) {
                    return;
                }
                task = std::move(tasks.front());
                tasks.erase(tasks.begin());
            }
            task();
        }
    }

    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex mtx;
    std::condition_variable cv;
    bool stop = false;
};

5. 使用线程池： 现在可以在程序中使用线程池来执行多个任务。首先创建一个线程池实例，然后将要执行的任务添加到线程池中。

int main() {
    ThreadPool pool(4);

    std::vector<std::function<void()>> tasks = {
        [] { std::cout << "Task 1 is running in thread " << std::this_thread::get_id() << std::endl; },
        [] { std::cout << "Task 2 is running in thread " << std::this_thread::get_id() << std::endl; },
        [] { std::cout << "Task 3 is running in thread " << std::this_thread::get_id() << std::endl; },
    };

    for (const auto& task : tasks) {
        pool.enqueue(task);
    }

    return 0;
}

这个例子展示了如何在 Linux 中使用 C++ 编写可重用的多线程组件。你可以根据需要扩展这个类，以支持更多的功能和配置选项。