线程池: * 一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着 监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利 用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。
线程池的应用场景：
* 1. 需要大量的线程来完成任务，且完成任务的时间比较短。 WEB服务器完成网页请求这样的任务，使用线程池技 术是非常合适的。因为单个任务小，而任务数量巨大，你可以想象一个热门网站的点击次数。 但对于长时间的任务，比如一个 Telnet连接请求，线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了。
* 2. 对性能要求苛刻的应用，比如要求服务器迅速响应客户请求。
* 3. 接受突发性的大量请求，但不至于使服务器因此产生大量线程的应用。突发性大量客户请求，在没有线程池情 况下，将产生大量线程，虽然理论上大部分操作系统线程数目最大值不是问题，短时间内产生大量线程可能使内存到达极限， 出现错误.
线程池的种类：
* 线程池示例：
* 1. 创建固定数量线程池，循环从任务队列中获取任务对象，
* 2. 获取到任务对象后，执行任务对象中的任务接口
代码的大概整体结构：
#include "threadpool.hpp"
#include "task.hpp"
int main(){
threadpool<task>* tp=new threadpool<task>();
//在使用模板类时，始终需要提供具体的类型参数，这样编译器才能正确生成类型安全的代码。如果不加类型参数，将导致编译错误。
tp->init();
tp->start();
int cnt=10;
while(cnt){
//向线程池推任务
sleep(1);
task t(1,1);
tp->equeue(t);
sleep(1);
cout<<"cnt: "<<cnt--<<endl;
}
tp->stop();
cout<<"stop!!!!!!!"<<endl;
sleep(10);
return 0;
}
task.hpp
#pragma once
#include<iostream>
#include<functional>
using namespace std;
class task
{
public:
task() {}
task(int x, int y) : _x(x), _y(y)
{
}
void excute()
{
_result = _x + _y;
}
void operator()(){
excute();
}
string debug()
{
string msg = to_string(_x) + "+" + to_string(_y) + "=?";
return msg;
}
string result()
{
string msg = to_string(_x) + "+" + to_string(_y) +"="+ to_string(_result);
return msg;
}
~task()
{
}
private:
int _x;
int _y;
int _result;
};
thread.hpp
#pragma once
#include <iostream>
#include <string>
#include <pthread.h>
#include <functional> //回调方法
using namespace std;
namespace threadmodel // 构造一个命名空间
{
//typedef void (*func_t)(threaddate *td);
// typedef void (*func_t)(const string &name); // func_t 是一个指向返回类型为 void 且有参数的函数的指针。
// // func_t 现在可以用作一个函数指针类型的别名，表示任何指向带字符串参数且返回类型为 void 的函数的指针。
using func_t=function<void(const string&)>;//返回值为void，参数为空的函数类型
class thread
{
public:
void excute()
{
cout << _name << " is running ! " << endl;
_running = true;
_func(_name); // 回调不仅回调运行，他还得结束
_running = false; // 回调完就结束了
}
public:
thread(const string &name, func_t func) : _name(name), _func(func)
{
cout << "create: " << name << " done! " << endl;
}
static void *threadroutine(void *agv) // 只要线程启动，新线程都会启动这个方法
{ // 因为是类内定义的方法，所以会隐含一个this指针参数,加了static就可以，这是因为 static 成员函数不与类的实例相关联，因此它不需要 this 指针。
thread *self = static_cast<thread *>(agv); // 获得当前对象。因为要调用_func，但_func是动态的，静态函数无法访问所以传this指针访问
self->excute();
return nullptr;
}
bool start()
{ // 线程启动方法
int n = ::pthread_create(&_tid, nullptr, threadroutine, this);
// 使用::pthread_create确保调用的是全局命名空间中的pthread_create函数,避免当前命名空间内可能存在的同名函数的影响。
// 直接使用 pthread_create 会根据当前命名空间查找，如果找到了同名函数，就会调用那个函数。
if (n != 0)
return false;
return true;
}
string status()
{
if (_running)
{
return "running";
}
else
return "sleep";
}
void stop()
{ // 线程停止方法
if (_running)
{ // 得先有线程才能停止
_running = false; // 状态停止
::pthread_cancel(_tid);
cout << _name << " stop ! " << endl;
}
}
void join()
{ // 线程等待方法
if (!_running)
{ // 没有running才值得join
::pthread_join(_tid, nullptr);
cout << _name << " join ! " << endl;
}
}
string threadname()
{
return _name;
}
~thread()
{
}
private:
string _name; // 线程的名字
pthread_t _tid; // 线程的id
bool _running; // 是否处于工作状态
func_t _func; // 线程要执行的回调函数
};
};
threadpool.hpp
#pragma once
#include <iostream>
#include <unistd.h>
#include <string>
#include <vector>
#include <queue>
#include <functional>
#include "thread.hpp"
using namespace std;
using namespace threadmodel;
static const int faultnum = 5;
void test()
{
while (true)
{
cout << "hello world" << 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(const string &name)
{ // 每个线程都执行这个方法
while (true)
{
// 拿任务
lockqueue();
while (isempty() && _isrunning) // 没任务并且线程不退出
{ // 防止伪唤醒·用while
// 为空的任务列表，那就去休眠
_sleep_thread_num++;
Sleep();
_sleep_thread_num--;
}
// 判定一种情况
if (isempty() && !_isrunning)
{ // 任务队列空的并且线程池想退出
cout << name << ": " << " quit" << endl ;
unlockqueue();
break;
}
// 有任务
T t = _task_queue.front(); // 取任务
_task_queue.pop(); // 老任务弹走
unlockqueue();
t(); // 处理任务，此处不用/不能在临界区中处理，避免浪费时间因为任务已经是你的了，你自己去处理，不占用公共资源
cout << name << ": " << t.result() << endl;
}
}
public:
threadpool(int thread_num = faultnum) : _thread_num(thread_num), _isrunning(false), _sleep_thread_num(0)
{
pthread_mutex_init(&_mutex, nullptr);
pthread_cond_init(&_cond, nullptr);
}
void init()
{ // 初始化
func_t func = bind(&threadpool::handlertask, this, placeholders::_1);
for (int i = 0; i < _thread_num; i++)
{
string threadname = "thread-" + to_string(i + 1);
_threads.emplace_back(threadname, func); // 提供名字和任务
// emplace_back它的作用是在容器的末尾直接构造一个对象。emplace_back允许你直接传递构造对象所需的参数
}
}
void start()
{ // 开始
_isrunning = true;
for (auto &threadd : _threads)
{
threadd.start();
}
}
void equeue(const T &in)
{ // 向线程池中推送任务
lockqueue(); // 加
if (_isrunning)//运行才可以
{
_task_queue.push(in);
if (_sleep_thread_num > 0)
wakeup(); // 唤醒
}
unlockqueue(); // 解
}
void stop()
{
lockqueue();
_isrunning = false;
wakeupall();
unlockqueue();
}
~threadpool()
{
pthread_mutex_destroy(&_mutex);
pthread_cond_destroy(&_cond);
}
private:
int _thread_num; // 期待有多少线程
vector<thread> _threads; // 对象全在这里
queue<T> _task_queue; // 任务队列,他就是临界资源
bool _isrunning; // 是否运行
int _sleep_thread_num; // 休眠的线程的个数
pthread_mutex_t _mutex; // 对queue的锁
pthread_cond_t _cond; // 条件变量
};
**日志：**软件运行的记录信息，向显示器打印，向文件打印，特定的格式(统一格式输出) ；
格式：[日志等级][pid][filename][filenumber][time] 日志内容(支持可变参数)；
日志等级：1. DEBUG
//详细的信息，用于调试程序。包括内部状态和控制流的信息。通常在开发和测试阶段使用。
2. INFO
//一般信息，表示程序正常运行时的重要事件。例如系统启动、关闭或者某个操作成功完成等。
3. WARNING
//警告信息，表示可能会导致问题的事件。并不意味着错误，但可能需要注意的情况，例如某个功能即将过时。
4. ERROR
//错误信息，表示程序中发生了问题。这些问题会影响某个特定的功能或操作，但不会导致程序崩溃。
5. FATAL --致命的
//**致命错误，表示程序遇到严重问题并即将停止运行。**例如，关键资源不可用，无法继续执行。