Linux学习记录——이십칠 多线程（4）
文章目录
- 1、线程池
-
- 1、V1：简易版本
- 2、V2：用线程类来封装
- 3、V3：用线程类 + 锁来封装
- 2、线程安全的单例模式——V4
- 3、智能指针、线程安全
- 4、常见的各种锁
- 5、读者写者问题
1、线程池
池化技术是一种以空间换时间的技术，在用户申请线程之前，系统就预先创建了一些线程，用户发来申请请求时，系统就把这个请求封装成任务请求发给线程，线程也就被调用了。线程池本质上是一个生产者消费者模型，线程池是消费者，用户是生产者。
接下来写的是简单的线程池的设计。
服务器中，有任务队列，和预先创建好的线程，有很多的客户端，发送请求给服务器，服务器把所有请求放在任务队列中，然后发放给线程们。我们要实现的就是简单的服务器的操作。
1、V1：简易版本
创建main.cc，ThreadPool.hpp，makefile
makefile
ThreadPool:main.cc
g++ -o $@ $^ -std=c++11 -lpthread
.PHONY:clean
clean:
rm -f ThreadPool
main.cc
#include "ThreadPool.hpp"
using namespace std;
int main()
{
unique_ptr> tp(new ThreadPool());//智能指针
tp->init();
tp->start();
while(true)
{
//充当生产者
sleep(1);
}
return 0;
}
ThreadPool_V1.hpp
#pragma once
#include //智能指针的头文件
#include _threads;
int _num;
std::queue _tasks;//使用STL的自动扩容
pthread_mutex_t _lock;
pthread_cond_t _cond;//当没有任务，所有线程应当休息，挂起，所以用条件变量来控制
};
没有任务，所有线程就都等待。写一个推送任务的函数，这个函数内部的操作要用锁保护起来，推送完后就唤醒线程，然后线程执行自己的函数。threadRoutine这个函数，因为不能直接用类内的成员，所以我们传this指针，然后把参数args强制转换成ThreadPool类型，把它所要用的函数都写出来放在类中以供调用。
template<class T>
class ThreadPool
{
public:
ThreadPool(int num = N):_num(num), _threads(num)//也可以不初始化_threads，因为我们用的是库，直接push就行
{
pthread_mutex_init(&_lock, nullptr);
pthread_cond_init(&_cond, nullptr);
}
void LockQueue() {pthread_mutex_lock(&_lock); }
void UnlockQueue() {pthread_mutex_unlock(&_lock); }
void ThreadWait() {pthread_cond_wait(&_cond, &_lock);
void ThreadWakeup() {pthread_cond_signal(&_cond); }
bool isEmpty() {return _tasks.empty(); }
T popTask()
{
T t = _tasks.front();
_tasks.pop();
return t;
}
static void* threadRoutine(coid* args)//加static？类内的线程函数，要记得加static，放在静态区，因为在类内会有this指针，导致函数参数类型不对
{
pthread_deatach(pthread_self());
ThreadPool* tp = static_cast*>(args);
while(true)
{
//1、检测有没有任务，有就处理，无就等待，这里一定要加锁
tp->LockQueue();
//因为是静态函数，不能直接访问类内私有成员，所以create函数那里要传this指针就可以了
if(tp->isEmpty())
{
tp->threadWait();
}
T t = tp->popTask()//从公共区域拿到私有区域
tp->UnlockQueue();
t.run();//处理任务
}
}
void init()
{
;
}
void start()
{
for(int i = 0; i < _num; i++)
{
pthread_create(&_threads[i], nullptr, threadRoutine, this);
}
}
void pushTask(const T& t)
{
LockQueue();
_task.push(t);
ThreadWait();
UnlockQueue();
}
~ThreadPool()
{
pthread_mutex_destroy(&_lock);
pthread_cond_destroy(&_cond);
}
private:
std::vector _threads;
int _num;
std::queue _tasks;//使用STL的自动扩容
pthread_mutex_t _lock;
pthread_cond_t _cond;//当没有任务，所有线程应当休息，挂起，所以用条件变量来控制
};
接下来是run函数。锁需要保护的是获取数据，而不是处理数据，所以run函数应当在解锁之后执行。
现在做一下测试，用之前的task.hpp文件。
static void* threadRoutine(coid* args)//加static？类内的线程函数，要记得加static，放在静态区，因为在类内会有this指针，导致函数参数类型不对
{
pthread_deatach(pthread_self());
ThreadPool* tp = static_cast*>(args);
while(true)
{
//1、检测有没有任务，有就处理，无就等待，这里一定要加锁
tp->LockQueue();
//因为是静态函数，不能直接访问类内私有成员，所以create函数那里要传this指针就可以了
if(tp->isEmpty())
{
tp->threadWait();
}
T t = tp->popTask()//从公共区域拿到私有区域
tp->UnlockQueue();
//测试
t();
std::cout << "thread handler done, result: " <.formatRes() << std::endl;
//t.run();//处理任务
}
}
int main()
{
unique_ptr> tp(new ThreadPool());//智能指针
tp->init();
tp->start();
while(true)
{
int x, y;
char op;
cout << "please enter x: " << endl;
cin >> x;
cout << "please enter y: " << endl;
cin >> y;
cout << "please enter op(+-*/%): " << endl;
cin >> op;
Task t(x, y, op);
tp->pushTask(t);
//充当生产者，从网络中读取数据，构建成为任务，推送给线程池
sleep(1);
tp->pushTask();
}
return 0;
}
2、V2：用线程类来封装
之前写过一个有线程类的文件Thread.hpp
#pragma once
#include 用这个文件代替库中的pthread.h头文件。
//这几个函数需要做改动，以及threadRoutine函数类型改成static void即可。
void init()
{
//插入若干个线程
for(int i = 0; i < _num; i++)
{
_threads.push_back(Thread(i, threadRoutine, this));
//pthread_create(&_threads[i], nullptr, threadRoutine, this);
}
}
void start()
{
for(auto& t: _threads)
{
t.run();
}
}
void check()
{
for(auto& t: _threads)
{
std::cout << t.threadname() << "running..." << std::endl;
}
}
~ThreadPool()
{
for(auto& t: _threads)
{
t.join();
}
pthread_mutex_destroy(&_lock);
pthread_cond_destroy(&_cond);
}
private:
std::vector _threads;//pthread_t是用的库中的
int _num;
std::queue _tasks;//使用STL的自动扩容
pthread_mutex_t _lock;
pthread_cond_t _cond;//当没有任务，所有线程应当休息，挂起，所以用条件变量来控制
3、V3：用线程类 + 锁来封装
我们之前也写过一个互斥锁的简单封装，所以这里就用这个锁的类来改一下文件
LockGuard.hpp
#pragma once
#include 一切加锁和解锁都可以用类来自动完成，而在threadRoutine函数中就得调用类中的函数来写。
ThreadPool_V3.hpp
#pragma once
#include //智能指针的头文件
#include * tp = static_cast*>(args);
while(true)
{
T t;
{//括号里就是临界区
//1、检测有没有任务，有就处理，无就等待，这里一定要加锁
LockGuard lockguard(tp->getlock());
//因为是静态函数，不能直接访问类内私有成员，所以create函数那里要传this指针就可以了
if(tp->isEmpty())
{
tp->threadWait();
}
t = tp->popTask()//从公共区域拿到私有区域
}
//测试
t();
std::cout << "thread handler done, result: " <.formatRes() << std::endl;
//t.run();//处理任务
}
}
void init()
{
//插入若干个线程
for(int i = 0; i < _num; i++)
{
_threads.push_back(Thread(i, threadRoutine, this));
}
}
void start()
{
for(auto& t: _threads)
{
t.run();
}
}
void check()
{
for(auto& t: _threads)
{
std::cout << t.threadname() << "running..." << std::endl;
}
}
void pushTask(const T& t)
{
LockGuard lockguard(&_lock);//V2是调用系统接口，V3就是调用我们自己写的类，初始化，函数结束时自动析构，也就是释放锁
_task.push(t);
ThreadWait();
}
~ThreadPool()
{
for(auto& t: _threads)
{
t.join();
}
pthread_mutex_destroy(&_lock);
pthread_cond_destroy(&_cond);
}
private:
std::vector _threads;//pthread_t是用库中的
int _num;
std::queue _tasks;//使用STL的自动扩容
pthread_mutex_t _lock;
pthread_cond_t _cond;//当没有任务，所有线程应当休息，挂起，所以用条件变量来控制
};
2、线程安全的单例模式——V4
单例模式是类只实例化一个对象的模式。有饿汉和懒汉实现方式。饿汉是程序加载进内存时就实例化对象，懒汉是用的时候才实例化。
现在我们把线程池设计成单例的，让整个线程池只有一个，由我们控制，用户只能获取。我们要定义一个静态的线程池对象，对它的初始化要放在类外。构造函数需要私有化，不去掉，去掉C++默认生成的拷贝构造，=重载函数，析构函数还是public。然后就是禁止别人创建对象。
private:
ThreadPool(int num = N):_num(num), _threads(num)//也可以不初始化_threads，因为我们用的是库，直接push就行
{
pthread_mutex_init(&_lock, nullptr);
pthread_cond_init(&_cond, nullptr);
}
ThreadPool(const ThreadPool& tp) = delete;//去掉默认生成的函数
void operator = (const ThreadPool& tp) = delete;//去掉默认生成的函数
public:
static ThreadPool* getinstance()//这个要设置成静态的，因为如果cc文件中要调用这个静态对象的函数的话，函数也应当是静态的才行
{
if(nullptr == instance)
{
instance = new ThreadPool();
}
return instance;
}
//...
private:
std::vector _threads;//pthread_t是用库中的
int _num;
std::queue _tasks;//使用STL的自动扩容
pthread_mutex_t _lock;
pthread_cond_t _cond;//当没有任务，所有线程应当休息，挂起，所以用条件变量来控制
static ThreadPool* instance;//对象
};
template<class T>
ThreadPool* ThreadPool::instance = nullptr;//类外初始化
main.cc中先去掉和tp有关的代码
#include "ThreadPool.hpp"
#include "task.hpp"
using namespace std;
int main()
{
/*unique_ptr> tp(new ThreadPool());//智能指针
tp->init();
tp->start();*/
while(true)
{
int x, y;
char op;
cout << "please enter x: " << endl;
cin >> x;
cout << "please enter y: " << endl;
cin >> y;
cout << "please enter op(+-*/%): " << endl;
cin >> op;
Task t(x, y, op);
ThreadPool::getinstance()->pushTask(t);
//tp->pushTask(t);
//充当生产者，从网络中读取数据，构建成为任务，推送给线程池
sleep(1);
tp->pushTask();
}
return 0;
}
在main.cc的while之前写上ThreadPool< Task >::getinstance()，创建一个对象。运行起来后，我们并不能得到想要的结果，输入xyop后没反应，这是因为虽然上面代码中new了一个，但是没有初始化。
static ThreadPool* getinstance()//这个要设置成静态的，因为如果cc文件中要调用这个静态对象的函数的话，函数也应当是静态的才行
{
if(nullptr == instance)
{
instance = new ThreadPool();
instance->init();
instance->start();
}
return instance;
}
现在我们的代码是没有问题，但是单例对象也可以在多线程中使用，那么此时上面的代码就不对了。getinstance中，一个线程new了一个，紧接着被切走了，然后后面几个线程也都这样，那么系统中就有很多个对象了，也就不是单例了，所以我们需要加锁，锁也得是静态的。
static ThreadPool* getinstance()//这个要设置成静态的，因为如果cc文件中要调用这个静态对象的函数的话，函数也应当是静态的才行
{
LokcGuard lockguard(&instance_lock);//用锁类
if(nullptr == instance)
{
instance = new ThreadPool();
instance->init();
instance->start();
}
return instance;
}
//...
static ThreadPool* instance;//对象
static pthread_mutex_t instance_lock;//静态锁
};
template<class T>
ThreadPool* ThreadPool::instance = nullptr;//类外初始化
template<class T>
pthread_mutex_t ThreadPool::instance_lock = PTHREAD_MUTEX_INITIALIZER;
单例对象初始化那里，其实初始化只会发生一次，但是每个线程都得去加锁，然后判断一下，所以锁放在那里有点不合适。
static ThreadPool* getinstance()//这个要设置成静态的，因为如果cc文件中要调用这个静态对象的函数的话，函数也应当是静态的才行
{
if(nullptr == instance)//提高效率
{
LokcGuard lockguard(&instance_lock);//用锁类
if(nullptr == instance)
{
instance = new ThreadPool();
instance->init();
instance->start();
}
}
return instance;
}
只有第一次会进入if中，然后加锁，然后初始化，之后的线程只会判断一次然后直接返回。
到此结束，V4版本是最终版本，之后还会使用这个文件。
3、智能指针、线程安全
STL中的大部分容器都不是安全的，因为它们设计的初衷就不是考虑线程安全的。
智能指针中，unique_ptr也不涉及线程安全问题，shared_ptr用引用计数来解决线程安全，也有别的解决办法。
4、常见的各种锁
当申请锁失败时，自旋锁不会让申请的线程挂起，系统会让它持续申请，轮询式查看能否申请成功。互斥锁申请失败就会挂起等待，自旋锁则会频繁申请，这个动作也称为自旋。自旋还是挂起等待，要看访问临界区的时间，如果很长就挂起等待，时间短就自旋，自旋很消耗CPU的时间。
看一下如何使用自旋锁。要引用头文件pthread.h，pthread_spinlock_lock，pthread_spinlock_init，pthread_spinlock_destory，pthread_spinlock_trylock，pthread_spinlock_unlock。lock函数会自旋申请锁，trylock如果申请失败也就返回了。自旋锁和之前的锁的写法一样。
5、读者写者问题
读写端，写写之间是互斥的，读读之间是没有关系的，读写是互斥和同步的。在之前的生产消费模型中，消费者之间是互斥的，而读者之间没有关系，是因为读者不拿走数据。读写者有读写锁。pthread_rwlock_init等函数，用法和互斥锁一样。读者加锁是pthread_rdlock，写者加锁是pthread_wrlock。
看一个伪代码
int reader_cnt = 0;//读者数量
pthread_mutex_t lock;//锁
sem_t w(1);//写者要加载的信号量
//读者
pthread_mutex_lock(&lock)
if(reader_cnt == 0) P(w);//读者申请信号量，写者就拿不到了
reader_cnt++;
pthread_mutex_unlock(&lock)
//读者退出时
pthread_mutex_lock(&lock)
reader_cnt--;
if(reader_cnt == 0) V(w)//写者可以进来了
pthread_mutex_unlock(&lock)
//写者
P(w);//申请信号量
if(reader_cnt > 0)//说明还有读者，那就释放锁，做V操作，然后就不做写操作了
{
V(w);
挂起等待;
}
//到了这里，说明没有读者了，就可以写入
V(w)
如果读者很多，一直在P，写者长时间无法拿到信号量，就会导致写者饥饿问题，也就是一个线程长时间申请不到锁。针对这个问题，有两个办法，读者优先和写者优先策略，上述代码就是读者优先。写者优先是写者来访问时，让当前读者读完，后面的读者不让读。大部分都使用读者优先，修改、写入的频率都比较低。原生线程库默认采用读者优先策略。即使改成写者优先，体现地也不够明显。
多线程部分结束，接下来就是网络。
本篇gitee
结束。