1、C++设计模式——单例模式
2、C++基础组件——线程池实现
- C++系列文章目录
- 前言
- 一、线程池定义
- 线程池解决什么问题
- 二、C语言实现
- 三、C++实现
- 1.v1版本
- 问题
- 2.v2版本
- 总结
前言
实现线程池，给出C语言版以及两个C++版的实现方法，解决了一些常见问题，总结了遇到的问题及解决方法。
一、线程池定义
线程池解决什么问题池化技术，起到了建立缓冲区的作用：内存池、数据库连接池、消息池（消息队列）、对象池
1、解决任务处理
2、阻塞IO
3、解决线程创建与销毁的成本问题
4、管理线程
在日志系统中，直接写磁盘的话，性能会被限制在磁盘的读写能力上面，引入线程池，达到异步解耦的作用
二、C语言实现三大组件：
1、执行队列，线程
2、任务队列，任务
3、管理组件
#include 每个工作线程实际上一直在执行回调函数，在wait语句处阻塞，等待插入任务。传递信号量后，所有线程争抢任务，得到任务的线程执行，其余线程继续等待。
对任务进行加锁是防止多个线程同时取得任务，对任务进行修改，任务只能是固定参数。
三、C++实现 1.v1版本
使用单例模式包装线程池，全局仅产生一个对象
#pragma once
#ifndef _MYTHREADPOOL_V1_H_
#define _MYTHREADPOOL_V1_H_
#include#include"MyThreadPool_v1.h"
#include "windows.h"
#includelock(taskmutex); //上锁
auto func = std::bind(&MyThreadPool_v1::CallBack, this, i);//绑定
WorkThreads.push_back(std::make_unique<std::thread>(func));//加入指向func的独占指针，类型是线程类
}
printf("WorkThreads.size(): %d\n", WorkThreads.size());
}
MyThreadPool_v1::~MyThreadPool_v1() {
{
std::unique_lock<std::mutex> lock(taskmutex);
running = false;
}
//通知所有工作线程重新抢锁并重新判断wait条件，唤醒后因为running为false了，所以都会结束
cond.notify_all();//通知全部线程
// 等待所有工作线程结束
for (const auto &workthread : WorkThreads) {
workthread->join();//由于线程都开始竞争了，因此必定会执行完，join可等待线程执行完
}
}
void MyThreadPool_v1::CallBack(int id) {
printf("WorkThread: %d start\n", id);
while (1) {
std::unique_lock<std::mutex> lock(this->taskmutex);
while (Tasks.empty()) { //当任务队列为空时一直循环
if (running == false) {
break;
}
cond.wait(lock); //阻塞
}
if (running == false) {
break;
}
Task task;
{ //同步 *** 作
task = Tasks.front();
Tasks.pop();
}
//解锁
printf("Work(%d):start\n", id);
task.task();//执行任务
char ch[10];
strcpy_s(ch, task.name.c_str());
printf("正在执行的任务id：%s\n",ch);
printf("Work(%d):end\n", id);
}
printf("Work(%d):stoped\n", id);
}
void MyThreadPool_v1::PushTask(ThreadPoolTask task, std::string name) {
{
//加锁
std::unique_lock<std::mutex> lock(taskmutex);
Tasks.push({ task,name });
char ch[10];
strcpy_s(ch, name.c_str());
}
cond.notify_one();//通知一个进程
}
void MyThreadPool_v1::desstory() {
{
std::unique_lock<std::mutex> lock(taskmutex);
running = false;
}
//通知所有工作线程重新抢锁并重新判断wait条件，唤醒后因为running为false了，所以都会结束
cond.notify_all();//通知全部线程
// 等待所有工作线程结束
for (const auto &workthread : WorkThreads) {
workthread->join();//由于线程都开始竞争了，因此必定会执行完，join可等待线程执行完
}
}
#include"MyThreadPool_v1.h"
#include当前台线程结束后，程序结束，main函数结束会强制所有后台子线程结束
1.任务执行时间长时，当main函数退出时，所有子线程被迫退出
2.单例线程池无法自动析构
3.任务函数参数不可变
2.v2版本使用智能指针的单例模式实现线程池
使用C++11新特性实现可变参数模板，可以执行不同参数的任务
#pragma once
#ifndef _MYTHREADPOOL_V2_H_
#define _MYTHREADPOOL_V2_H_
#include#include"MyThreadPool_v2.h"
std::shared_ptr<MyThreadPool_v2> MyThreadPool_v2::GetInstacne(int threadnums) {
//第一次声明静态对象是线程安全的，存在静态区域
static std::shared_ptr<MyThreadPool_v2> instacne_v2(new MyThreadPool_v2(threadnums));
return instacne_v2;
}
MyThreadPool_v2::MyThreadPool_v2(int threadnums) {
//int threadnums = 4;
printf("构造函数\n");
for (int i = 0; i < threadnums; ++i) {
//每一个线程执行一个匿名函数
printf("线程%d开始执行\n", i);
//匿名函数包含加锁，阻塞，取任务，执行，即之前的回调函数
WorkThreads.emplace_back
(
[this]
{
for (;;)
{
ThreadPoolTask task;//任务对象
{
std::unique_lock<std::mutex> lock(this->taskmutex);
/**等待条件成立(当线程池被关闭或有可消费任务时跳过wait继续；否则cond.wait将会unlock释放锁，
* *其他线程可以继续拿锁，但此线程会阻塞此处并休眠，直到被notify_*唤醒，被唤醒时wait会再次lock并判断条件是否成立，
* *如成立则跳过wait，否则unlock并休眠继续等待下次唤醒)
* */
this->cond.wait(lock, [this] { return !this->running || !this->Tasks.empty(); });
// 如果线程池停止且任务队列为空，说明需要关闭线程池结束返回
if (!running&&Tasks.empty()) {
return;
}
// 取得任务队首任务(注意此处的std::move)
task = std::move(this->Tasks.front());
// 从队列移除
this->Tasks.pop();
}
//执行任务
task();
}
}
);
}
}
MyThreadPool_v2::~MyThreadPool_v2() {
printf("析构函数\n");
{
std::unique_lock<std::mutex> lock(taskmutex);
running = false;
}
//通知所有工作线程重新抢锁并重新判断wait条件，唤醒后因为running为false了，所以都会结束
cond.notify_all();//通知全部线程
// 等待所有工作线程结束
for (auto &workthread : WorkThreads) {
workthread.join();//由于线程都开始竞争了，因此必定会执行完，join可等待线程执行完
}
}
#include 在单例模式中使用了智能指针，最后的析构交由智能指针实现。C++11标准中静态对象的线程安全创建，其静态对象必须在GetInstance函数中第一次声明，不必使用双重检验来保证线程安全。PushTask函数定义了可变参数模板，使用了C++11的新特性，后置推导参数类型传递给auto，这两篇文章讲的非常详细参考1，参考2。
总结
记录一下实现线程池遇到的问题，并和之前的单例模式结合实现，其应用场景非常广泛，其中若有bug欢迎大家指出，期待指导。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）