c++线程复用|极客笔记

c++线程复用

在c++中，线程是一种轻量级的执行单元，用于并行执行任务。线程的创建和销毁都会带来一定的开销，因此在实际开发中，我们往往会尽量避免频繁地创建和销毁线程，而是尝试复用已经创建好的线程。本文将详细介绍如何在c++中实现线程的复用，以提高程序的性能和效率。

线程的基本概念

在c++11标准中，提供了std::thread类用于管理线程。使用std::thread可以创建新的线程，并指定要执行的函数或者函数对象。下面是一个简单的示例代码：

#include <iostream>
#include <thread>

void myFunction() {
    std::cout << "This is my function" << std::endl;
}

int main() {
    std::thread t(myFunction);
    t.join();

    return 0;
}

上面的示例中，我们定义了一个名为myFunction的函数，然后在主函数main中创建了一个线程t并指定要执行的函数为myFunction。最后调用t.join()等待线程执行完毕。

线程的复用

在实际开发中，我们经常需要执行大量的任务，如果每个任务都创建一个新的线程，那么线程的创建和销毁开销将会很大。为了提高程序的性能和效率，我们希望能够复用已经创建好的线程，来执行不同的任务。

实现线程的复用有多种方式，比较常见的方式是使用线程池。线程池是一种管理线程的机制，可以预先创建一组线程，并维护一个任务队列。当有任务到来时，从任务队列中取出一个线程来执行，任务执行完毕后该线程不销毁，而是保留在线程池中供下一次任务使用。

下面是一个简单的线程池实现示例代码：

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

class ThreadPool {
public:
    ThreadPool(size_t numThreads) : stop(false) {
        for (size_t i = 0; i < numThreads; ++i)
            threads.push_back(std::thread(&ThreadPool::worker, this));
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            stop = true;
        }
        condition.notify_all();

        for (size_t i = 0; i < threads.size(); ++i)
            threads[i].join();
    }

    template<class F>
    void addTask(F&& task) {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            tasks.push(std::function<void()>(task));
        }
        condition.notify_one();
    }

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

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

    void worker() {
        while (true) {
            std::function<void()> task;
            {
                std::unique_lock<std::mutex> lock(queueMutex);
                condition.wait(lock, [this]{ return stop || !tasks.empty(); });

                if (stop && tasks.empty())
                    return;

                task = tasks.front();
                tasks.pop();
            }
            task();
        }
    }
};

void myFunction(int id) {
    std::cout << "Thread " << id << " is running." << std::endl;
}

int main() {
    ThreadPool pool(4);

    for (int i = 0; i < 8; ++i) {
        pool.addTask([i](){ myFunction(i); });
    }

    std::this_thread::sleep_for(std::chrono::seconds(2));

    return 0;
}

上面的示例中，我们定义了一个ThreadPool类用于管理线程池。在构造函数中创建了指定数量的线程，并在worker函数中实现了任务的执行逻辑。在addTask函数中将任务加入到任务队列中，并通过condition.notify_one()通知线程池有新任务，线程池中的线程会自动执行。

运行结果

当执行上述示例代码时，可以看到如下输出：

Thread 0 is running.
Thread 1 is running.
Thread 2 is running.
Thread 3 is running.
Thread 4 is running.
Thread 5 is running.
Thread 6 is running.
Thread 7 is running.

可以看到，线程池中的4个线程被复用，依次执行了8个任务。