子非线程池中物
线程池,又好上了
有任务队列
任务要处理就直接放到里面
预先创建好线程,本质上也是一个生产消费模型
线程池真是麻烦啊
我们可以直接沿用之前写过的代码,Thread.hpp:
#pragma once
#include <iostream>
#include <functional>
#include <string>
#include <pthread.h>namespace ThreadMoudle
{class ThreadData{public:ThreadData(const std::string &name, pthread_mutex_t *lock) : _name(name), _lock(lock){}public: // 正常来说应该是私有但是我不想写接口了凑合看吧std::string _name;pthread_mutex_t *_lock;};// 线程要执行的方法using func_t = std::function<void()>; //返回值是void,参数是空//typedef void (*func_t)(ThreadData *td); // 函数指针类型class Thread{public:void Excute(){_isrunning = true;_func();_isrunning = false;}public:Thread(const std::string &name, func_t func) : _name(name), _func(func){std::cout<<"create"<<name<<"done"<<std::endl;}static void *ThreadRoutine(void *args) // 新线程执行的方法{Thread *self = static_cast<Thread *>(args); // 获得当前对象self->Excute();return nullptr;}bool Start(){int n = ::pthread_create(&_tid, nullptr, ThreadRoutine, this); // 这个::指用系统提供的if (n != 0){return false;}return true;}std::string Status() // 线程启动检测下状态{if (_isrunning){return "running";}return "sleep";}void Stop(){if (_isrunning){::pthread_cancel(_tid);_isrunning = false;}}void Join(){::pthread_join(_tid, nullptr);std::cout << "join done" << std::endl;}std::string Name(){return _name;}~Thread(){Stop();Join();}private:std::string _name;pthread_t _tid;bool _isrunning;func_t _func; // 线程要执行的回调函数//ThreadData *_td;// std::string _result; //返回值,不关心的话也可以不用写};
}
这是新写的热乎线程池:
#pragma once#include<iostream>
#include<unistd.h>
#include<string>
#include<vector>
#include<queue>
#include"Thread.hpp"using namespace ThreadMoudle;static const int gdefaultnum = 5;void test()
{while (true){std::cout << "hello EPI?" << std::endl;sleep(1); }
}template<typename T>
class ThreadPool
{
public:ThreadPool(int thraed_num = gdefaultnum):_thread_num(thraed_num),_isrunning(false){}void Init(){for(int i=0;i<_thread_num;i++){std::string threadname = "thread-" + std::to_string(i+1);_threads.emplace_back(threadname,test);}}void Start(){for(auto &thread:_threads){thread.Start();}}void Stop(){}void Enqueue(const T &in){}~ThreadPool(){}
private:int _thread_num;std::vector<Thread> _threads;std::queue<T> _task_queue;bool _isrunning;
};
Makefile:
threadpool:Main.ccg++ -o $@ $^ -std=c++11 -lpthread
.PHONY:clean
clean:rm -f threadpool
Main.cc:
#include"ThreadPool.hpp"int main()
{//std::unique_ptr<ThreadPool> tp = std::make_unique<ThreadPool>();ThreadPool<int> *tp = new ThreadPool<int>();tp->Init();tp->Start();while (true){//不断向线程池中推送任务sleep(1);}return 0;
}
这是成就:
我们的队列是一个临界资源,我们要对它进行保护捏
这个_task_queue队列是要被主线程访问的
为什么用锁不用信号量呢?
因为都是整体使用,会使用这里的各种属性,我们无法确定里面什么样子
这个线程池的设计思想就是
有任务就去执行
如果没任务就该休眠勒
终于可以正常运行勒,,,
遇到的bug:线程休眠的个数初始设置成0了导致检测的时候检测不到都没有被唤醒
就像是早八的时候一个宿舍都在睡觉
任务还是用之前的代码,唤醒的时候要用while以避免伪唤醒的情况
在初始化中用bind让一个模块能调用另一个模块的方法,,捏
ThreadPool.hpp:
#pragma once#include<iostream>
#include<unistd.h>
#include<functional>
#include<string>
#include<vector>
#include<pthread.h>
#include<queue>
#include"Thread.hpp"using namespace ThreadMoudle;static const int gdefaultnum = 5;void test()
{while (true){std::cout << "hello EPI?" << std::endl;sleep(1); }
}template<typename T>
class ThreadPool
{
private:void LockQueue(){pthread_mutex_lock(&_mutex);}void UnLockQueue(){pthread_mutex_unlock(&_mutex);}void WakeUp(){pthread_cond_signal(&_cond);}void Sleep(){pthread_cond_wait(&_cond,&_mutex);}bool IsEmpty(){return _task_queue.empty();}void HandlerTask(){while (true){LockQueue();while(IsEmpty()) //为了防止伪唤醒的情况发生{_sleep_thread_num++; //保证加锁和解锁都安全更新Sleep();_sleep_thread_num--;}//有任务T t = _task_queue.front(); //取出_task_queue.pop(); //老的弹出去UnLockQueue();t(); //处理任务,不能在临界区处理std::cout << t.debug() << std::endl;}}
public:ThreadPool(int thraed_num = gdefaultnum):_thread_num(thraed_num),_isrunning(false),_sleep_thread_num(0){pthread_mutex_init(&_mutex,nullptr);pthread_cond_init(&_cond,nullptr);}void Init(){func_t func = std::bind(&ThreadPool::HandlerTask,this); //让this和handlertask强关联起来,能让一个模块调用另一个类中的方法for(int i=0;i<_thread_num;i++){std::string threadname = "thread-" + std::to_string(i+1);_threads.emplace_back(threadname,func);}}void Start(){for(auto &thread:_threads){thread.Start();}}void Stop(){}void Enqueue(const T &in){LockQueue(); //加锁_task_queue.push(in);if(_sleep_thread_num > 0){WakeUp();}UnLockQueue(); //解锁}~ThreadPool(){pthread_mutex_destroy(&_mutex);pthread_cond_destroy(&_cond);}
private:int _thread_num;std::vector<Thread> _threads;std::queue<T> _task_queue;bool _isrunning;int _sleep_thread_num; //我们定义一个计数器来确定什么时候唤醒它pthread_mutex_t _mutex;pthread_cond_t _cond;
};
Thread.hpp:
#pragma once
#include <iostream>
#include <functional>
#include <string>
#include <pthread.h>namespace ThreadMoudle
{class ThreadData{public:ThreadData(const std::string &name, pthread_mutex_t *lock) : _name(name), _lock(lock){}public: // 正常来说应该是私有但是我不想写接口了凑合看吧std::string _name;pthread_mutex_t *_lock;};// 线程要执行的方法using func_t = std::function<void()>; //返回值是void,参数是空//typedef void (*func_t)(ThreadData *td); // 函数指针类型class Thread{public:void Excute(){_isrunning = true;_func();_isrunning = false;}public:Thread(const std::string &name, func_t func) : _name(name), _func(func){std::cout<<"create"<<name<<"done"<<std::endl;}static void *ThreadRoutine(void *args) // 新线程执行的方法{Thread *self = static_cast<Thread *>(args); // 获得当前对象self->Excute();return nullptr;}bool Start(){int n = ::pthread_create(&_tid, nullptr, ThreadRoutine, this); // 这个::指用系统提供的if (n != 0){return false;}return true;}std::string Status() // 线程启动检测下状态{if (_isrunning){return "running";}return "sleep";}void Stop(){if (_isrunning){::pthread_cancel(_tid);_isrunning = false;}}void Join(){::pthread_join(_tid, nullptr);std::cout << "join done" << std::endl;}std::string Name(){return _name;}~Thread(){Stop();Join();}private:std::string _name;pthread_t _tid;bool _isrunning;func_t _func; // 线程要执行的回调函数//ThreadData *_td;// std::string _result; //返回值,不关心的话也可以不用写};
}
Main.cc:
#include"ThreadPool.hpp"
#include"Task.hpp"int main()
{//std::unique_ptr<ThreadPool> tp = std::make_unique<ThreadPool>();ThreadPool<Task> *tp = new ThreadPool<Task>();tp->Init();tp->Start();while (true){//不断向线程池中推送任务sleep(1);Task t(1,1);tp->Enqueue(t);sleep(1);}return 0;
}
Makefile:
threadpool:Main.ccg++ -o $@ $^ -std=c++11 -lpthread
.PHONY:clean
clean:rm -f threadpool
Task.hpp:
#pragma once#include <iostream>
#include <string>class Task
{
public:Task() : x(0), y(0) {}Task(int a, int b) : x(a), y(b) {}// 执行任务,计算结果void operator()() {result_value = x + y; // 示例操作:计算 x 和 y 的和}// 返回结果int result() const {return result_value;}// 调试输出std::string debug() const {return "Task: x = " + std::to_string(x) + ", y = " + std::to_string(y);}private:int x; // 第一个参数int y; // 第二个参数int result_value; // 计算结果
};
荷叶饭说如果把Makefile都交上去了那证明没什么可交勒
关于线程池退出 方面需要先厘清逻辑,就是如果它任务队列为空而且要退出那就退出捏:
#pragma once#include <iostream>
#include <unistd.h>
#include <functional>
#include <string>
#include <vector>
#include <pthread.h>
#include <queue>
#include "Thread.hpp"using namespace ThreadMoudle;static const int gdefaultnum = 5;void test()
{while (true){std::cout << "hello EPI?" << std::endl;sleep(1);}
}template <typename T>
class ThreadPool
{
private:void LockQueue(){pthread_mutex_lock(&_mutex);}void UnLockQueue(){pthread_mutex_unlock(&_mutex);}void WakeUp(){pthread_cond_signal(&_cond);}void WakeUpAll(){pthraed_cond_broadcast(&_cond);}void Sleep(){pthread_cond_wait(&_cond, &_mutex);}bool IsEmpty(){return _task_queue.empty();}void HandlerTask(){while (true){LockQueue();while (IsEmpty() && _isrunning) // 为了防止伪唤醒的情况发生{_sleep_thread_num++; // 保证加锁和解锁都安全更新Sleep();_sleep_thread_num--;}// 判定一种情况if (IsEmpty() && !_isrunning) // 空了并且退出那就退罢{std::cout << name << "quit" << std::endl;UnLockQueue();break;}// 有任务T t = _task_queue.front(); // 取出_task_queue.pop(); // 老的弹出去UnLockQueue();t(); // 处理任务,不能在临界区处理std::cout << t.debug() << std::endl;}}public:ThreadPool(int thraed_num = gdefaultnum) : _thread_num(thraed_num), _isrunning(false), _sleep_thread_num(0){pthread_mutex_init(&_mutex, nullptr);pthread_cond_init(&_cond, nullptr);}void Init(){func_t func = std::bind(&ThreadPool::HandlerTask, this); // 让this和handlertask强关联起来,能让一个模块调用另一个类中的方法for (int i = 0; i < _thread_num; i++){std::string threadname = "thread-" + std::to_string(i + 1);_threads.emplace_back(threadname, func);}}void Start(){_isrunning = true;for (auto &thread : _threads){thread.Start();}}void Stop(){LockQueue();_isrunning = false;WakeUpAll();UnLockQueue();}void Enqueue(const T &in){LockQueue(); // 加锁if (_isrunning){_task_queue.push(in);if (_sleep_thread_num > 0){WakeUp();}}UnLockQueue(); // 解锁}~ThreadPool(){pthread_mutex_destroy(&_mutex);pthread_cond_destroy(&_cond);}private:int _thread_num;std::vector<Thread> _threads;std::queue<T> _task_queue;bool _isrunning;int _sleep_thread_num; // 我们定义一个计数器来确定什么时候唤醒它pthread_mutex_t _mutex;pthread_cond_t _cond;
};
总结
线程池: 一种线程使用模式。线程过多会带来调度开销,进而影响缓存局部性和整体性能。而线程池维护着多个线程,等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。
线程池不仅能够保证内核的充分利用,还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。
线程池的应用场景:
1. 需要大量的线程来完成任务,且完成任务的时间比较短。 WEB服务器完成网页请求这样的任务,使用线程池技术是非常合适的。因为单个任务小,而任务数量巨大,你可以想象一个热门网站的点击次数。 但对于长时间的任务,比如一个Telnet连接请求,线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了
2. 对性能要求苛刻的应用,比如要求服务器迅速响应客户请求
3. 接受突发性的大量请求,但不至于使服务器因此产生大量线程的应用。突发性大量客户请求,在没有线程池情 况下,将产生大量线程,虽然理论上大部分操作系统线程数目最大值不是问题,短时间内产生大量线程可能使内存到达极限, 出现错误
线程池示例:
1. 创建固定数量线程池,循环从任务队列中获取任务对象
2. 获取到任务对象后,执行任务对象中的任务接口
线程安全的单例模式
劳斯,什么是单例模式?
单例模式是一种经典的常用的常考的设计模式
什么是设计模式?(有一种递归的感觉由于什么都不知道导致需要连续的搜索一个概念中的另一个概念)
IT行业这么火, 涌入的人很多. 俗话说林子大了啥鸟都有. 大佬和菜鸡们两极分化的越来越严重. 为了让菜鸡们不太拖大佬的后腿, 于是大佬们针对一些经典的常见的场景, 给定了一些对应的解决方案, 这个就是设计模式,,,球球你们不要再跟我比了,计算机比肩土木就都老实勒
《未毕业勿扰》
单例模式的特点:
某些类, 只应该具有一个对象(实例), 就称之为单例,例如一个男人只能有一个媳妇,在很多服务器开发场景中,经常需要让服务器加载很多的数据 (上百G) 到内存中
此时往往要用一个单例的类来管理这些数据
饿汉方式和懒汉方式
关于单例模式的实现,有饿汉方式和懒汉方式
拿洗碗来举例子:
吃完饭, 立刻洗碗, 这种就是饿汉方式. 因为下一顿吃的时候可以立刻拿着碗就能吃饭
吃完饭, 先把碗放下, 然后下一顿饭用到这个碗了再洗碗, 就是懒汉方式
懒汉方式最核心的思想是 "延时加载". 从而能够优化服务器的启动速度
这是饿汉方式:
template <typename T>
class Singleton
{ static T data;
public: static T* GetInstance() { return &data; }
};
通过Single这个包装类来使用T对象,则一个进程只有一个T对象的实例
这是懒汉方式:
template <typename T>
class Singleton
{ static T* inst;
public: static T* GetInstance() { if (inst == NULL) { inst = new T(); } return inst; }
};
但是这个实现会造成线程不安全的问题
在第一次嗲用GetInstance的时候,如果两个线程同时调用,可能会创建出两份T对象的实例,但后续再次调用就没问题勒
日志是软件运行的记录信息,可以向显示器打印,也可以向文件中打印,这个要有特定的格式
[日志等级][pid][filename][filenumber]日志内容(支持可变参数)
日志等级分为debug(调试信息)和info(常规信息)和warning(警告)和error(错误)和fatal(致命错误)
我们来写一个日志罢,方便看到输出
耶,Log.hpp:
#pragma#include <iostream>
#include<unistd.h>
#include<sys/types.h>
#include<ctime>enum
{DEBUG = 1,INFO,WARNING,ERRNO,FATAL
};std::string LevelToString(int level)
{switch (level){case DEBUG:return "DEBUG";case INFO:return "INFO";case WARNING:return "WARNING";case ERRNO:return "ERRNO";case FATAL:return "FATAL";default:return "UNKNOW";}
}std::string GetCurTime()
{time_t now = time(nullptr);struct tm *curr_time = localtime(&now);char buffer[128];snprintf(buffer,sizeof(buffer),"%d-%02d-%02d : %02d-%02d-%02d",\curr_time->tm_year+1900,\curr_time->tm_mon+1,\curr_time->tm_mday,\curr_time->tm_hour,\curr_time->tm_min,\curr_time->tm_sec);return buffer;
}class logmessage
{
public:std::string _level;pid_t _id;std::string _filename;int _filenumber;std::string _curr_time;std::string _message_info;
};
class Log
{
public:Log(){}void LogMessage(std::string filename,int filenumber,int level,const char* format,...) //介素可变参数{logmessage lg;lg._level = LevelToString(level);lg._id = getpid();lg._filename = filename;lg._filenumber =filenumber;lg._curr_time = GetCurTime();}~Log(){}
private:
};// int main()
// {// return 0;
// }
可变参数是从右到左入栈的
#pragma#include <iostream>
#include<unistd.h>
#include<sys/types.h>
#include<ctime>
#include<stdarg.h>enum
{DEBUG = 1,INFO,WARNING,ERRNO,FATAL
};std::string LevelToString(int level)
{switch (level){case DEBUG:return "DEBUG";case INFO:return "INFO";case WARNING:return "WARNING";case ERRNO:return "ERRNO";case FATAL:return "FATAL";default:return "UNKNOW";}
}std::string GetCurTime()
{time_t now = time(nullptr);struct tm *curr_time = localtime(&now);char buffer[128];snprintf(buffer,sizeof(buffer),"%d-%02d-%02d : %02d-%02d-%02d",\curr_time->tm_year+1900,\curr_time->tm_mon+1,\curr_time->tm_mday,\curr_time->tm_hour,\curr_time->tm_min,\curr_time->tm_sec);return buffer;
}class logmessage
{
public:std::string _level;pid_t _id;std::string _filename;int _filenumber;std::string _curr_time;std::string _message_info;
};
class Log
{
public:Log(){}void LogMessage(std::string filename,int filenumber,int level,const char* format,...) //介素可变参数{logmessage lg;lg._level = LevelToString(level);lg._id = getpid();lg._filename = filename;lg._filenumber =filenumber;lg._curr_time = GetCurTime();va_list ap;va_start(ap,format); //初始化char log_info[1024];vsnprintf(log_info,sizeof(log_info),format,ap);va_end(ap);lg._message_info = log_info;std::cout << lg._message_info << std::endl;}~Log(){}
private:
};// int main()
// {// return 0;
// }
#include"ThreadPool.hpp"
#include"Task.hpp"
#include"Log.hpp"int main()
{std::cout << GetCurTime() << std::endl;Log lg;lg.LogMessage("main.cc",10,DEBUG,"hello %d,world: %c,hello: %f\n",1000,'A',3.14);return 0;
}
我恨你啊
我的茶餐厅,,,
没了全没了
为什么呢?
可能因为我喜欢吧。
来看看怎么把消息打到文件里吧:
#pragma#include <iostream>
#include<unistd.h>
#include<sys/types.h>
#include<ctime>
#include<stdarg.h>
#include<fstream>
#include<cstring>#define SCREEN_TYPE 1
#define FILE_TYPE 2const std::string glogfile = "./log.txt";enum
{DEBUG = 1,INFO,WARNING,ERRNO,FATAL
};std::string LevelToString(int level)
{switch (level){case DEBUG:return "DEBUG";case INFO:return "INFO";case WARNING:return "WARNING";case ERRNO:return "ERRNO";case FATAL:return "FATAL";default:return "UNKNOW";}
}std::string GetCurTime()
{time_t now = time(nullptr);struct tm *curr_time = localtime(&now);char buffer[128];snprintf(buffer,sizeof(buffer),"%d-%02d-%02d : %02d-%02d-%02d",\curr_time->tm_year+1900,\curr_time->tm_mon+1,\curr_time->tm_mday,\curr_time->tm_hour,\curr_time->tm_min,\curr_time->tm_sec);return buffer;
}class logmessage
{
public:std::string _level;pid_t _id;std::string _filename;int _filenumber;std::string _curr_time;std::string _message_info;
};
class Log
{
public:Log(const std::string &logfile = glogfile):_logfile(logfile),_type(SCREEN_TYPE){}void Enable(int type){_type = type;}void FlushLogToScreen(const logmessage &lg){printf("[%s][%d][%s][%d][%s] %s",lg._level.c_str(),lg._id,lg._filename.c_str(),lg._filenumber,lg._curr_time,lg._message_info);}void FlushLogToFile(const logmessage &lg){std::ofstream out(_logfile);if(!out.is_open()){return;}char logtxt[2048];snprintf(logtxt,sizeof(logtxt),"[%s][%d][%s][%d][%s] %s",lg._level.c_str(),lg._id,lg._filename.c_str(),lg._filenumber,lg._curr_time,lg._message_info);out.write(logtxt,strlen(logtxt));out.close();}void FlushLog(const logmessage &lg){switch(_type){case SCREEN_TYPE:FlushLogToScreen(lg);break;case FILE_TYPE:FlushLogToFile(lg);break;}}void LogMessage(std::string filename,int filenumber,int level,const char* format,...) //介素可变参数{logmessage lg;lg._level = LevelToString(level);lg._id = getpid();lg._filename = filename;lg._filenumber =filenumber;lg._curr_time = GetCurTime();va_list ap;va_start(ap,format); //初始化char log_info[1024];vsnprintf(log_info,sizeof(log_info),format,ap);va_end(ap);lg._message_info = log_info;//打印出来日志FlushLog(lg);}~Log(){}
private:int _type;std::string _logfile;
};// int main()
// {// return 0;
// }
#include"ThreadPool.hpp"
#include"Task.hpp"
#include"Log.hpp"int main()
{std::cout << GetCurTime() << std::endl;Log lg;lg.Enable(FILE_TYPE);lg.LogMessage("main.cc",10,DEBUG,"hello %d,world: %c,hello: %f\n",1000,'A',3.14);return 0;
}
这个打印乱码不知道为什么,好像是说什么强制类型转换出问题了
我也不知道哪错了那就不改了吧
do while(0)是保证宏替换的安全问题
#pragma#include <iostream>
#include<unistd.h>
#include<sys/types.h>
#include<ctime>
#include<stdarg.h>
#include<fstream>
#include<cstring>
#include"LockGuard.hpp"#define SCREEN_TYPE 1
#define FILE_TYPE 2const std::string glogfile = "./log.txt";
pthread_mutex_t glock = PTHREAD_MUTEX_INITIALIZER;enum
{DEBUG = 1,INFO,WARNING,ERRNO,FATAL
};std::string LevelToString(int level)
{switch (level){case DEBUG:return "DEBUG";case INFO:return "INFO";case WARNING:return "WARNING";case ERRNO:return "ERRNO";case FATAL:return "FATAL";default:return "UNKNOW";}
}std::string GetCurTime()
{time_t now = time(nullptr);struct tm *curr_time = localtime(&now);char buffer[128];snprintf(buffer,sizeof(buffer),"%d-%02d-%02d : %02d-%02d-%02d",\curr_time->tm_year+1900,\curr_time->tm_mon+1,\curr_time->tm_mday,\curr_time->tm_hour,\curr_time->tm_min,\curr_time->tm_sec);return buffer;
}class logmessage
{
public:std::string _level;pid_t _id;std::string _filename;int _filenumber;std::string _curr_time;std::string _message_info;
};class Log
{
public:Log(const std::string &logfile = glogfile):_logfile(logfile),_type(SCREEN_TYPE){}void Enable(int type){_type = type;}void FlushLogToScreen(const logmessage &lg){printf("[%s][%d][%s][%d][%s][%s]",lg._level.c_str(),lg._id,lg._filename.c_str(),lg._filenumber,lg._curr_time,lg._message_info);}void FlushLogToFile(const logmessage &lg){std::ofstream out(_logfile,std::ios::app);if(!out.is_open()){return;}char logtxt[2048];snprintf(logtxt,sizeof(logtxt),"[%s][%d][%s][%d][%s] %s",lg._level.c_str(),lg._id,lg._filename.c_str(),lg._filenumber,lg._curr_time,lg._message_info);out.write(logtxt,strlen(logtxt));out.close();}void FlushLog(const logmessage &lg){//加过滤逻辑,可以把等级过滤出去LockGuard lockguard(&glock);switch(_type){case SCREEN_TYPE:FlushLogToScreen(lg);break;case FILE_TYPE:FlushLogToFile(lg);break;}}void LogMessage(std::string filename,int filenumber,int level,const char* format,...) //介素可变参数{logmessage lg;lg._level = LevelToString(level);lg._id = getpid();lg._filename = filename;lg._filenumber =filenumber;lg._curr_time = GetCurTime();va_list ap;va_start(ap,format); //初始化char log_info[1024];vsnprintf(log_info,sizeof(log_info),format,ap);va_end(ap);lg._message_info = log_info;//打印出来日志FlushLog(lg);}~Log(){}
private:int _type;std::string _logfile;
};Log lg;#define LOG(Level,Format,...)do{lg.LogMessage(__FILE__,__LINE__,Level,Format,##__VA_ARGS__); }while(0)
#define EnableScreen() do {lg.Enable(SCREEN_TYPE);}while(0)
#define EnableFILE() do{lg.Enable(FILE_TYPE;)}while(0)
赫赫恨
亲爱的荷叶饭如果 你看到这里
和我一起改bug,我在这存个档
Log.hpp:
#pragma once#include <iostream>
#include<unistd.h>
#include<sys/types.h>
#include<ctime>
#include<stdarg.h>
#include<fstream>
#include<cstring>
#include"LockGuard.hpp"#define SCREEN_TYPE 1
#define FILE_TYPE 2
//下面这个是改进之后
Log lg;#define LOG(Level, Format, ...) do { \lg.LogMessage(__FILE__, __LINE__, Level, Format, ##__VA_ARGS__); \
} while(0)
//#define LOG(Level,Format,...) do{lg.LogMessage(__FILE__,__LINE__,Level,Format,##__VA_ARGS__);}while(0)
#define EnableScreen() do {lg.Enable(SCREEN_TYPE);}while(0)
#define EnableFILE() do{lg.Enable(FILE_TYPE);}while(0)const std::string glogfile = "./log.txt";
pthread_mutex_t glock = PTHREAD_MUTEX_INITIALIZER;enum LogLevel
{DEBUG = 1,INFO,WARNING,ERRNO,FATAL
};std::string LevelToString(int level)
{switch (level){case DEBUG:return "DEBUG";case INFO:return "INFO";case WARNING:return "WARNING";case ERRNO:return "ERRNO";case FATAL:return "FATAL";default:return "UNKNOW";}
}std::string GetCurTime()
{time_t now = time(nullptr);struct tm *curr_time = localtime(&now);char buffer[128];snprintf(buffer,sizeof(buffer),"%d-%02d-%02d : %02d-%02d-%02d",\curr_time->tm_year+1900,\curr_time->tm_mon+1,\curr_time->tm_mday,\curr_time->tm_hour,\curr_time->tm_min,\curr_time->tm_sec);return buffer;
}class logmessage
{
public:std::string _level;pid_t _id;std::string _filename;int _filenumber;std::string _curr_time;std::string _message_info;
};class Log
{
public:Log(const std::string &logfile = glogfile):_logfile(logfile),_type(SCREEN_TYPE){}void Enable(int type){_type = type;}void FlushLogToScreen(const logmessage &lg){printf("[%s][%d][%s][%d][%s][%s]",lg._level.c_str(),lg._id,lg._filename.c_str(),lg._filenumber,lg._curr_time.c_str(),lg._message_info.c_str());}void FlushLogToFile(const logmessage &lg){std::ofstream out(_logfile,std::ios::app);if(!out.is_open()){return;}char logtxt[2048];snprintf(logtxt,sizeof(logtxt),"[%s][%d][%s][%d][%s] %s",lg._level.c_str(),lg._id,lg._filename.c_str(),lg._filenumber,lg._curr_time.c_str(),lg._message_info.c_str());out.write(logtxt,strlen(logtxt));out.close();}void FlushLog(const logmessage &lg){//加过滤逻辑,可以把等级过滤出去LockGuard lockguard(&glock);switch(_type){case SCREEN_TYPE:FlushLogToScreen(lg);break;case FILE_TYPE:FlushLogToFile(lg);break;}}void LogMessage(std::string filename,int filenumber,int level,const char* format,...) //介素可变参数{logmessage lg;lg._level = LevelToString(level);lg._id = getpid();lg._filename = filename;lg._filenumber =filenumber;lg._curr_time = GetCurTime();va_list ap;va_start(ap,format); //初始化char log_info[1024];vsnprintf(log_info,sizeof(log_info),format,ap);va_end(ap);lg._message_info = log_info;//打印出来日志FlushLog(lg);}~Log(){}
private:int _type;std::string _logfile;
};
ThreadPool.hpp:
#pragma once#include"Log.hpp"
#include <iostream>
#include <unistd.h>
#include <functional>
#include <string>
#include <vector>
#include <pthread.h>
#include <queue>
#include "Thread.hpp"using namespace ThreadMoudle;static const int gdefaultnum = 5;void test()
{while (true){std::cout << "hello EPI?" << std::endl;sleep(1);}
}template <typename T>
class ThreadPool
{
private:void LockQueue(){pthread_mutex_lock(&_mutex);}void UnLockQueue(){pthread_mutex_unlock(&_mutex);}void WakeUp(){pthread_cond_signal(&_cond);}void WakeUpAll(){pthread_cond_broadcast(&_cond);}void Sleep(){pthread_cond_wait(&_cond, &_mutex);}bool IsEmpty(){return _task_queue.empty();}void HandlerTask(){while (true){LockQueue();while (IsEmpty() && _isrunning) // 为了防止伪唤醒的情况发生{_sleep_thread_num++; // 保证加锁和解锁都安全更新Sleep();_sleep_thread_num--;}// 判定一种情况if (IsEmpty() && !_isrunning) // 空了并且退出那就退罢{std::cout << "quit" << std::endl;UnLockQueue();break;}// 有任务T t = _task_queue.front(); // 取出_task_queue.pop(); // 老的弹出去UnLockQueue();t(); // 处理任务,不能在临界区处理std::cout << t.debug() << std::endl;}}ThreadPool(int thread_num = gdefaultnum) : _thread_num(thread_num), _isrunning(false), _sleep_thread_num(0){pthread_mutex_init(&_mutex, nullptr);pthread_cond_init(&_cond, nullptr);}ThreadPool(const ThreadPool<T> &) = delete; //赫赫这就是我们单例模式void operator = (const ThreadPool<T> &) = delete;
public:void Init(){func_t func = std::bind(&ThreadPool::HandlerTask, this); // 让this和handlertask强关联起来,能让一个模块调用另一个类中的方法for (int i = 0; i < _thread_num; i++){std::string threadname = "thread-" + std::to_string(i + 1);_threads.emplace_back(threadname, func);}}void Start(){_isrunning = true;for (auto &thread : _threads){thread.Start();}}void Stop(){LockQueue();_isrunning = false;WakeUpAll();UnLockQueue();}static ThreadPool<T> *GetInstance(){if(_tp==nullptr){LOG(INFO,"create threadpool\n");_tp=new ThreadPool();_tp->Init();_tp->Start();}else{LOG(INFO,"get threadpool\n");}return _tp;}void Enqueue(const T &in){LockQueue(); // 加锁if (_isrunning){_task_queue.push(in);if (_sleep_thread_num > 0){WakeUp();}}UnLockQueue(); // 解锁}~ThreadPool(){pthread_mutex_destroy(&_mutex);pthread_cond_destroy(&_cond);}private:int _thread_num;std::vector<Thread> _threads;std::queue<T> _task_queue;bool _isrunning;int _sleep_thread_num; // 我们定义一个计数器来确定什么时候唤醒它pthread_mutex_t _mutex;pthread_cond_t _cond;//单例模式static ThreadPool<T> *_tp;};//静态指针的初始化需要在类外
template<typename T>
ThreadPool<T> *ThreadPool<T>::_tp = nullptr;
Main.cc:
#include"ThreadPool.hpp"
#include"Task.hpp"
#include"Log.hpp"int main()
{Log::FlushLogToScreen();int cnt = 10;while (cnt){sleep(1);Task t(1,1);ThreadPool<Task>::GetInstance()->Enqueue(t);LOG(INFO,"enqueue a task,%s\n",t.debug().c_str());sleep(1);cnt--;}ThreadPool<Task>::GetInstance()->Stop();LOG(INFO,"thraed pool stop!\n");return 0;
}
LockGuard.hpp:
#pragma once
#include<pthread.h>class LockGuard
{
public:LockGuard(pthread_mutex_t *mutex):_mutex(mutex){pthread_mutex_lock(_mutex);}~LockGuard(){pthread_mutex_unlock(_mutex);}private:pthread_mutex_t *_mutex;
};
Thread.hpp:
#pragma once
#include <iostream>
#include <functional>
#include <string>
#include <pthread.h>namespace ThreadMoudle
{class ThreadData{public:ThreadData(const std::string &name, pthread_mutex_t *lock) : _name(name), _lock(lock){}public: // 正常来说应该是私有但是我不想写接口了凑合看吧std::string _name;pthread_mutex_t *_lock;};// 线程要执行的方法using func_t = std::function<void()>; //返回值是void,参数是空//typedef void (*func_t)(ThreadData *td); // 函数指针类型class Thread{public:void Excute(){_isrunning = true;_func();_isrunning = false;}public:Thread(const std::string &name, func_t func) : _name(name), _func(func){std::cout<<"create"<<name<<"done"<<std::endl;}static void *ThreadRoutine(void *args) // 新线程执行的方法{Thread *self = static_cast<Thread *>(args); // 获得当前对象self->Excute();return nullptr;}bool Start(){int n = ::pthread_create(&_tid, nullptr, ThreadRoutine, this); // 这个::指用系统提供的if (n != 0){return false;}return true;}std::string Status() // 线程启动检测下状态{if (_isrunning){return "running";}return "sleep";}void Stop(){if (_isrunning){::pthread_cancel(_tid);_isrunning = false;}}void Join(){::pthread_join(_tid, nullptr);std::cout << "join done" << std::endl;}std::string Name(){return _name;}~Thread(){Stop();Join();}private:std::string _name;pthread_t _tid;bool _isrunning;func_t _func; // 线程要执行的回调函数//ThreadData *_td;// std::string _result; //返回值,不关心的话也可以不用写};
}
拜托了小蜜蜂君
相关文章:

子非线程池中物
线程池,又好上了 有任务队列 任务要处理就直接放到里面 预先创建好线程,本质上也是一个生产消费模型 线程池真是麻烦啊 我们可以直接沿用之前写过的代码,Thread.hpp: #pragma once #include <iostream> #include <functional&…...

Unraid的cache使用btrfs或zfs?
Unraid的cache使用btrfs或zfs? 背景:由于在unraid中添加了多个docker和虚拟机,因此会一直访问硬盘。然而,单个硬盘实在难以让人放心。在阵列盘中,可以通过添加校验盘进行数据保护,在cache中无法使用xfs格式…...
微服务实战——平台属性
平台属性 中间表复杂业务 /*** 获取分类规格参数(模糊查询)** param params* param catelogId* param type type"base"时查询基础属性,type"sale"时查询销售属性* return*/ Override public PageUtils listByCatelogId…...

半监督学习与数据增强(论文复现)
半监督学习与数据增强(论文复现) 本文所涉及所有资源均在传知代码平台可获取 文章目录 半监督学习与数据增强(论文复现)概述算法原理核心逻辑效果演示使用方式 概述 本文复现论文提出的半监督学习方法,半监督学习&…...

css3-----2D转换、动画
2D 转换(transform) 转换(transform)是CSS3中具有颠覆性的特征之一,可以实现元素的位移、旋转、缩放等效果 移动:translate旋转:rotate缩放:scale 二维坐标系 2D 转换之移动 trans…...

SQL进阶技巧:统计各时段观看直播的人数
目录 0 需求描述 1 数据准备 2 问题分析 3 小结 如果觉得本文对你有帮助,那么不妨也可以选择去看看我的博客专栏 ,部分内容如下: 数字化建设通关指南 专栏 原价99,现在活动价39.9,十一国庆后将上升至59.9&#…...

Stream流的终结方法
1.Stream流的终结方法 2.forEach 对于forEach方法,用来遍历stream流中的所有数据 package com.njau.d10_my_stream;import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.function.Consumer; import java.util…...

JavaWeb——Vue组件库Element(4/6):案例:基本页面布局(基本框架、页面布局、CSS样式、完善布局、效果展示,含完整代码)
目录 步骤 基本页面布局 基本框架 页面布局 CSS样式 完善布局 效果展示 完整代码 Element 的基本使用方式以及常见的组件已经了解完了,接下来要完成一个案例,通过这个案例让大家知道如何基于 Element 中的各个组件制作一个完整的页面。 案例&am…...

【c++】 模板初阶
泛型编程 写一个交换函数,在学习模板之前,为了匹配不同的参数类型,我们可以利用函数重载来实现。 void Swap(int& a, int& b) {int c a;a b;b c; } void Swap(char& a, char& b) {char c a;a b;b c; } void Swap(dou…...
R 语言 data.table 大规模数据处理利器
前言 最近从一个 python 下的 anndata 中提取一个特殊处理过的单细胞矩阵,想读入R用来画图(个人比较喜欢用R可视化 ),保存之后,大概几个G的CSV文件,如果常规方法读入R,花费的时间比较久&#x…...
Java 静态代理详解:为什么代理类和被代理类要实现同一个接口?
在 Java 开发中,代理模式是一种常用的设计模式,其中代理类的作用是控制对其他对象的访问。代理模式分为静态代理和动态代理,在静态代理中,代理类和被代理类都需要实现同一个接口。这一机制为实现透明的代理行为提供了基础…...
OpenCV C++霍夫圆查找
OpenCV 中的霍夫圆检测基于 霍夫变换 (Hough Transform),它是一种从边缘图像中识别几何形状的算法。霍夫圆检测是专门用于检测图像中的圆形形状的。它通过将图像中的每个像素映射到可能的圆参数空间,来确定哪些像素符合圆形状。 1. 霍夫变换的原理 霍夫…...
H.264编解码介绍
一、简介 H.264,又称为AVC(Advanced Video Coding),是一种广泛使用的视频压缩标准。它由国际电信联盟(ITU)和国际标准化组织(ISO)联合开发,并于2003年发布。 H.264的发展历史可以追溯到上个世纪90年代。当时,视频压缩技术的主要标准是MPEG-2,但它在压缩率和视频质…...

Java | Leetcode Java题解之第450题删除二叉搜索树中的节点
题目: 题解: class Solution {public TreeNode deleteNode(TreeNode root, int key) {TreeNode cur root, curParent null;while (cur ! null && cur.val ! key) {curParent cur;if (cur.val > key) {cur cur.left;} else {cur cur.rig…...

【CViT】Deepfake Video Detection Using Convolutional Vision Transformer
文章目录 Deepfake Video Detection Using Convolutional Vision Transformerkey points**卷积视觉变压器**FLViT实验总结Deepfake Video Detection Using Convolutional Vision Transformer 会议/期刊:2021 作者: key points 提出了一种用于检测深度伪造的卷积视觉变压器…...

安卓主板_MTK4G/5G音视频记录仪整机及方案定制
音视频记录仪方案,采用联发科MT6877平台八核2* A78 6* A55主频高达2.4GHz, 具有高能低耗特性,搭载Android 12.0智能操作系统,可选4GB32GB/6GB128GB内存,运行流畅。主板集成NFC、双摄像头、防抖以及多种无线数据连接,支…...
Qt 教程全集目录公布(方便查阅)
点击上方"蓝字"关注我们 Qt 安装 以下是常见安装方法和软件获取 Qt4Qt5Qt6版本下载(在线和离线)【网址】...

云计算SLA响应时间的matlab模拟与仿真
目录 1.程序功能描述 2.测试软件版本以及运行结果展示 3.核心程序 4.本算法原理 5.完整程序 1.程序功能描述 用matlab模拟,一个排队理论。输入一堆包,经过buffer(一个或者几个都行)传给server,这些包会在buffer里…...

ARTS Week 42
Algorithm 本周的算法题为 2283. 判断一个数的数字计数是否等于数位的值 给你一个下标从 0 开始长度为 n 的字符串 num ,它只包含数字。 如果对于 每个 0 < i < n 的下标 i ,都满足数位 i 在 num 中出现了 num[i]次,那么请你返回 true …...

10.2学习
1.IOC控制反转 IoC(Inverse of Control:控制反转)是⼀种设计思想,就是将原本在程序中⼿动创建对象的控制权,交由Spring框架来管理。 IoC 在其他语⾔中也有应⽤,并⾮ Spring 特有。 IoC 容器是 Spring⽤来实现 IoC …...

Redis相关知识总结(缓存雪崩,缓存穿透,缓存击穿,Redis实现分布式锁,如何保持数据库和缓存一致)
文章目录 1.什么是Redis?2.为什么要使用redis作为mysql的缓存?3.什么是缓存雪崩、缓存穿透、缓存击穿?3.1缓存雪崩3.1.1 大量缓存同时过期3.1.2 Redis宕机 3.2 缓存击穿3.3 缓存穿透3.4 总结 4. 数据库和缓存如何保持一致性5. Redis实现分布式…...
深入浅出:JavaScript 中的 `window.crypto.getRandomValues()` 方法
深入浅出:JavaScript 中的 window.crypto.getRandomValues() 方法 在现代 Web 开发中,随机数的生成看似简单,却隐藏着许多玄机。无论是生成密码、加密密钥,还是创建安全令牌,随机数的质量直接关系到系统的安全性。Jav…...
【SpringBoot】100、SpringBoot中使用自定义注解+AOP实现参数自动解密
在实际项目中,用户注册、登录、修改密码等操作,都涉及到参数传输安全问题。所以我们需要在前端对账户、密码等敏感信息加密传输,在后端接收到数据后能自动解密。 1、引入依赖 <dependency><groupId>org.springframework.boot</groupId><artifactId...
【ROS】Nav2源码之nav2_behavior_tree-行为树节点列表
1、行为树节点分类 在 Nav2(Navigation2)的行为树框架中,行为树节点插件按照功能分为 Action(动作节点)、Condition(条件节点)、Control(控制节点) 和 Decorator(装饰节点) 四类。 1.1 动作节点 Action 执行具体的机器人操作或任务,直接与硬件、传感器或外部系统…...
MySQL用户和授权
开放MySQL白名单 可以通过iptables-save命令确认对应客户端ip是否可以访问MySQL服务: test: # iptables-save | grep 3306 -A mp_srv_whitelist -s 172.16.14.102/32 -p tcp -m tcp --dport 3306 -j ACCEPT -A mp_srv_whitelist -s 172.16.4.16/32 -p tcp -m tcp -…...
Rapidio门铃消息FIFO溢出机制
关于RapidIO门铃消息FIFO的溢出机制及其与中断抖动的关系,以下是深入解析: 门铃FIFO溢出的本质 在RapidIO系统中,门铃消息FIFO是硬件控制器内部的缓冲区,用于临时存储接收到的门铃消息(Doorbell Message)。…...

均衡后的SNRSINR
本文主要摘自参考文献中的前两篇,相关文献中经常会出现MIMO检测后的SINR不过一直没有找到相关数学推到过程,其中文献[1]中给出了相关原理在此仅做记录。 1. 系统模型 复信道模型 n t n_t nt 根发送天线, n r n_r nr 根接收天线的 MIMO 系…...
Linux离线(zip方式)安装docker
目录 基础信息操作系统信息docker信息 安装实例安装步骤示例 遇到的问题问题1:修改默认工作路径启动失败问题2 找不到对应组 基础信息 操作系统信息 OS版本:CentOS 7 64位 内核版本:3.10.0 相关命令: uname -rcat /etc/os-rele…...
NPOI Excel用OLE对象的形式插入文件附件以及插入图片
static void Main(string[] args) {XlsWithObjData();Console.WriteLine("输出完成"); }static void XlsWithObjData() {// 创建工作簿和单元格,只有HSSFWorkbook,XSSFWorkbook不可以HSSFWorkbook workbook new HSSFWorkbook();HSSFSheet sheet (HSSFSheet)workboo…...
「全栈技术解析」推客小程序系统开发:从架构设计到裂变增长的完整解决方案
在移动互联网营销竞争白热化的当下,推客小程序系统凭借其裂变传播、精准营销等特性,成为企业抢占市场的利器。本文将深度解析推客小程序系统开发的核心技术与实现路径,助力开发者打造具有市场竞争力的营销工具。 一、系统核心功能架构&…...