线程池+读写锁
读写锁介绍
读写锁： 为了处理多线程中读数据比写数据更频繁（读多写少），给读加锁会带来效率降低的问题，引入了一种新的锁——读写锁。读写锁实际是一种特殊的自旋锁，它把对共享资源的访问者划分成读者和写者，读者只对共享资源进行读访问，写者则需要对共享资源进行写操作。
自旋锁： 对应自旋锁，只有一个线程获得锁资源（与互斥锁），其他未得到锁资源的线程不是挂起等待，而是处于自旋状态，不断去检测锁的状态（自旋锁应用于线程占在临界区内待的时间特别短的场景）
特点：
- 三种关系： 读者和读者（共享）、读者和写者（互斥和同步） 和 写者和写者（互斥）
- 两个角色： 读者和写者
- 一份资源： 写操作，读读取
生产消费模型和读写锁的区别：
读写锁中读者不会拿走数据，但生产消费模型中的消费者会拿走数据，所以读写锁中读者与读者直接是可以共享数据
读写锁的三种同步方案：
读优先： 想尽一切办法让读者先读。当前为读锁，读者可直接进入，为写锁，当前为写锁，写者写完之后，让读者先进入读（可能会造成写饥饿问题）
写优先： 想尽一切办法让写者先写。当前为读锁或写锁，写者都不可以进入，读者读完或写者写完之后，写者可以先进入写
公平占有锁： 读者写者公平竞争锁
线程池介绍
线程池： 一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务，简单说：提前把线程创建好，等待任务的派发。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量
线程池的价值：
- 需要大量的线程来完成任务，且完成任务的时间比较短。可同时处理多任务，多请求。
- 有任务可以立即从线程池中调取线程取处理，节省了线程创建的时间
- 有效防止服务端线程过多而导致系统过载的问题
线程池与进程池：
- 线程池占用资源少，但是健壮性（鲁棒性）不强
- 进程池占用资源多，但是健壮性（鲁棒性）更强（涉及进程间通信，可利用管道的阻塞队列实现进程间同步和互斥）
实现
线程池中首先需要有很多个线程，用户可以自己选择创建多少个线程。为了实现线程间的同步与互斥，还需要增加两个变量——互斥量和条件变量。我们还需要一个任务队列，主线程不断往里面塞任务，线程池的线程不断去处理。需要注意的是：这里的任务队列可以为空，但不能满，所以任务队列的容量不限定
线程池的四个成员变量：
- 一个队列： 存放任务
- 线程池中线程数： 记录线程池中创建的线程数
- 互斥量： 一个互斥锁
- 条件变量： 队列为空时的条件变量
Mutex.hpp 锁的封装
#pragma once
#include ThreadPool.hpp 主要框架(唤醒和等待操作都已经封装好)
#pragma once
#include "Thread.hpp"
#include "Mutex.hpp"
#include 注意：
- 线程池中的任务队列存放的是任务指针类型，节省任务队列的空间开销
- 线程池的初始化操作不在构造函数中进行，而是提供了一个初始化接口（设计模式—单例模式），让用户自行调用。这是为了不让构造函数做有风险的事情（如果函数调用失败，会导致线程池创建失败）
thread.hpp 封装线程
需要注意的是，创建一个线程还需要提供一个线程启动后要执行的函数，这个启动函数只能有一个参数。如果把这个函数设置为成员函数，那么这个函数的第一个参数默认是this指针，这样显然是不可行的，所以这里我们考虑把这个启动函数设置为静态的。但是设置为静态的成员函数又会面临一个问题：如何调用其他成员函数和成员变量？ 所以这里我们考虑创建线程的时候，把this指针传过去，让启动函数的arg 参数去接收即可
#pragma once
#include **注意：**线程创建后，执行启动函数，在这个函数中，线程会去任务队列中取任务并处理，取任务前需要进行加锁的操作（如果队列为空需要挂起等待），取完任务然后进行解锁，然后处理任务，让其它线程去任务队列中取任务
task.hpp 构造任务
#pragma once
#include func_t;
public:
CalTask()
{}
CalTask(int x,int y,char op,func_t func)
:_x(x)
,_y(y)
,_op(op)
,_func(func)
{}
std::string operator()()
{
int res=_func(_x,_y,_op);
char buffer[64];
snprintf(buffer,sizeof(buffer),"%d %c %d = %d",_x,_op,_y,res);
return buffer;
}
std::string toTaskstring()
{
char buffer[64];
snprintf(buffer,sizeof(buffer),"%d %c %d = ?",_x,_op,_y);
return buffer;
}
private:
int _x;
int _y;
char _op;
func_t _func;
};
class SaveTask
{
using func_t=std::function<void(const std::string&)>;
public:
SaveTask()
{}
SaveTask(std::string& message,func_t func)
:_message(message)
,_func(func)
{}
void operator()()
{
_func(_message);
}
private:
std::string _message;
func_t _func;
};
void save(const std::string& message)
{
const std::string target="log.txt";
FILE* fp=fopen(target.c_str(),"a+");
if(fp==nullptr)
{
perror("fopen");
return ;
}
fputs(message.c_str(),fp);
fputs("\n",fp);
fclose(fp);
}
const std::string oper = "+-*/%";
int mymath(int x, int y, char op)
{
int result = 0;
switch (op)
{
case '+':
result = x + y;
break;
case '-':
result = x - y;
break;
case '*':
result = x * y;
break;
case '/':
{
if (y == 0)
{
std::cerr << "div zero error!" << std::endl;
result = -1;
}
else
result = x / y;
}
break;
case '%':
{
if (y == 0)
{
std::cerr << "mod zero error!" << std::endl;
result = -1;
}
else
result = x % y;
}
break;
default:
// do nothing
break;
}
return result;
}
test.cpp 主线程
主线程负责创建线程池，然后塞任务即可
#include "Thread.hpp"
#include "Task.hpp"
#include "ThreadPool.hpp"
#include> tp(new ThreadPool());
ThreadPool<CalTask>::getInstance()->start();
// tp->start();
while(1)
{
int x,y;
char op;
cout << "请输入数据1" << endl;
cin >> x ;
cout << "请输入数据2" << endl;
cin >> y;
cout << "请输入运算符" << endl;
cin >> op;
CalTask t(x,y,op,mymath);
ThreadPool<CalTask>::getInstance()->Push(t);
}
return 0;
}