文章目录
前言：
在多线程编程中，线程池是一种常用的技术，它可以有效地管理和调度线程。C++标准库中的和头文件提供了对线程池的支持。本文将介绍C++线程池的机制和原理。
一、线程池原理与实践
1、线程池的概念
线程池是一种线程使用模式，它通过预先创建多个线程，将任务提交给线程池，由线程池负责调度和执行任务。线程池的主要作用是减少线程创建和销毁的开销，提高程序的并发性能。
2、线程创建和销毁的开销有哪些？
线程创建与销毁的开销主要体现在以下几个方面：
2.1、系统资源消耗
- 内存分配：线程的创建需要为其分配一定的内存空间，以存储线程栈、线程控制块等数据结构。这些内存空间的分配和回收都需要消耗系统资源。
- 内核对象：在操作系统层面，线程的创建会涉及到内核对象的创建，这些对象用于管理线程的状态、优先级、调度等信息。同样地，线程的销毁也需要销毁这些内核对象。
2.2、初始化与清理
- 初始化：线程的创建需要进行一系列的初始化操作，如设置线程栈、初始化线程控制块等。这些操作都需要消耗一定的计算资源。
- 清理：线程的销毁需要执行一系列的清理操作，如释放线程栈、销毁线程控制块等。这些操作同样需要消耗计算资源。
2.3、上下文切换
- 当一个线程被创建或销毁时，操作系统需要进行上下文切换。上下文切换涉及到保存当前线程的上下文（如寄存器值、栈信息等）和加载新线程的上下文。这个过程需要消耗一定的CPU时间。
2.4、性能影响
- 创建开销：线程的创建通常比进程的创建要快，但在某些操作系统上，线程的创建仍然是一个相对昂贵的操作。例如，在Solaris 2操作系统上，创建进程的时间大约是创建线程的30倍。
- 销毁开销：线程的销毁同样需要一定的开销，特别是当线程被频繁创建和销毁时，这种开销会更加明显。
2.5、线程池的优势
- 减少开销：线程池通过预先创建一定数量的线程，并在需要时复用这些线程来执行任务，从而避免了频繁创建和销毁线程的开销。
- 提高性能：线程池通过限制并发线程的数量和有效地管理线程资源，可以提高系统的性能和资源利用率。
总结
线程创建与销毁的开销主要包括系统资源消耗、初始化与清理、上下文切换以及性能影响等方面。这些开销可以通过使用线程池等技术来降低，从而提高系统的整体性能和资源利用率。
3、线程池的机制
C++线程池主要由以下几个部分组成：
- 任务队列：用于存放待执行的任务。这些任务通常以函数对象、函数指针或可调用对象的形式存在。
- 线程集合：包含了一定数量的工作线程，这些线程会不断地从任务队列中取出任务并执行。
- 同步机制：用于协调线程之间的任务分配和状态同步。常见的同步机制包括互斥锁（mutex）、条件变量（condition variable）等。
- 线程管理：包括线程的创建、销毁、启动和停止等管理操作。为了优化性能，线程池通常会限制线程的最大数量，避免过多的线程创建和销毁开销。
cpp
#ifndef __THREAD_POOL_H__
#define __THREAD_POOL_H__
#include <atomic>
#include <condition_variable>
#include <future>
#include <iostream>
#include <mutex>
#include <queue>
#include <thread>
#include <vector>
#include <functional>
class NoneCopy {
public:
~NoneCopy(){}
protected:
NoneCopy(){}
private:
NoneCopy(const NoneCopy&) = delete;
NoneCopy& operator=(const NoneCopy&) = delete;
};
class ThreadPool : public NoneCopy {
public:
//继承基类NoneCopy就不需要写如下删除了
//ThreadPool(const ThreadPool&) = delete;
//ThreadPool& operator=(const ThreadPool&) = delete;
static ThreadPool& instance() {
static ThreadPool ins;
return ins;
}
using Task = std::packaged_task<void()>;
~ThreadPool() {
stop();
}
template <class F, class... Args>
auto commit(F&& f, Args&&... args) ->
std::future<decltype(std::forward<F>(f)(std::forward<Args>(args)...))> {
using RetType = decltype(std::forward<F>(f)(std::forward<Args>(args)...));
if (stop_.load())
return std::future<RetType>{};
auto task = std::make_shared<std::packaged_task<RetType()>>(
std::bind(std::forward<F>(f), std::forward<Args>(args)...));
std::future<RetType> ret = task->get_future();
{
std::lock_guard<std::mutex> cv_mt(cv_mt_);
tasks_.emplace([task] { (*task)(); });
}
cv_lock_.notify_one();
return ret;
}
int idleThreadCount() {
return thread_num_;
}
private:
ThreadPool(unsigned int num = std::thread::hardware_concurrency())
: stop_(false) {
{
/*
if (num <= 1)
thread_num_ = 2;
else
thread_num_ = num;
*/
thread_num_ = 10;
}
start();
}
void start() {
for (int i = 0; i < thread_num_; ++i) {
pool_.emplace_back([this]() {
while (!this->stop_.load()) {
Task task;
{
std::unique_lock<std::mutex> cv_mt(cv_mt_);
this->cv_lock_.wait(cv_mt, [this] {
return this->stop_.load() || !this->tasks_.empty();
});
if (this->tasks_.empty())
return;
task = std::move(this->tasks_.front());
this->tasks_.pop();
}
this->thread_num_--;
task();
this->thread_num_++;
}
});
}
}
void stop() {
stop_.store(true);
cv_lock_.notify_all();
for (auto& td : pool_) {
if (td.joinable()) {
std::cout << "join thread " << td.get_id() << std::endl;
td.join();
}
}
}
private:
std::mutex cv_mt_;
std::condition_variable cv_lock_;
std::atomic_bool stop_;
std::atomic_int thread_num_;
std::queue<Task> tasks_;
std::vector<std::thread> pool_;
};
#endif // !__THREAD_POOL_H__