目录
一、线程池
线程池的应用场景：
线程池示例：
二、线程安全的单例模式
什么是单例模式
什么是设计模式
单例模式的特点
饿汉实现方式和懒汉实现方式
三、STL,智能指针和线程安全
四、其他常见的各种锁
五、读者写者问题(了解)
读写锁
读写锁接口
一、线程池
线程池一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。
一句话就是我们事先创建好一批线程，有任务到来时就唤醒线程执行任务，没有任务时就休眠。
线程池的应用场景：
- 需要大量的线程来完成任务，且完成任务的时间比较短。 WEB服务器完成网页请求这样的任务，使用线程池技术是非常合适的。因为单个任务小，而任务数量巨大，你可以想象一个热门网站的点击次数。 但对于长时间的任务，比如一个Telnet连接请求，线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了。
- 对性能要求苛刻的应用，比如要求服务器迅速响应客户请求。
- 接受突发性的大量请求，但不至于使服务器因此产生大量线程的应用。突发性大量客户请求，在没有线程池情况下，将产生大量线程，虽然理论上大部分操作系统线程数目最大值不是问题，短时间内产生大量线程可能使内存到达极限，出现错误。
线程池示例：
* 1. 创建固定数量线程组成线程池，循环从任务队列中获取任务对象
* 2. 获取到任务对象后，执行任务对象中的任务接口
//pthreadPool.hpp
#pragma once
#include "thread.hpp"
#include "lockGroud.hpp"
#include "Task.hpp"
#include <vector>
#include <queue>
#include <unistd.h>
using namespace ThreadNS;
static const int gnum = 5;
template<class T>
class ThreadPool;
template<class T>
class ThreadData //大号结构体，方便我们传入线程的名字，后续再想传入一些内容可以在此添加
{
public:
ThreadData(ThreadPool<T>* in,const string& name)
:threadpool(in),_name(name)
{}
public:
ThreadPool<T>* threadpool;
string _name;
};
template<class T>
class ThreadPool
{
public:
ThreadPool(const int& num = gnum)
:_num(num)
{
pthread_mutex_init(&_mutex,nullptr); //初始化锁
pthread_cond_init(&_cond,nullptr); //初始化条件变量
for(int i = 0;i<_num;++i)
{
_threads.push_back(new Thread()); //创建线程
}
}
void push(const T& in)
{
// pthread_mutex_lock(&_mutex);
lockGroud lockgroud(&_mutex); //RAII的锁
_Task_queue.push(in); //给任务队列里插入任务
pthread_cond_signal(&_cond); //唤醒一个线程
// pthread_mutex_unlock(&_mutex);
}
void run()
{
for(auto& t:_threads)
{
//将要传入执行方法的参数打包成结构体传入
ThreadData<T>* td = new ThreadData<T>(this,t->threadname());
cout << t->threadname() << " 准备就绪" << endl;
t->start(handlerTask,td); //执行方法
}
}
~ThreadPool()
{
pthread_mutex_destroy(&_mutex); //销毁锁
pthread_cond_destroy(&_cond); //销毁条件变量
for(auto& t:_threads) delete t; //销毁线程
}
T pop()
{
T t = _Task_queue.front(); //取任务
_Task_queue.pop();
return t;
}
//一批接口
pthread_mutex_t* Mutex(){ return &_mutex;}
void threadlock() { pthread_mutex_lock(&_mutex); }
void threadunlock() { pthread_mutex_unlock(&_mutex); }
bool threadempty() { return _Task_queue.empty();}
void threadwait() { pthread_cond_wait(&_cond,&_mutex);}
private:
static void* handlerTask(void* args)
{
ThreadData<T>* td = static_cast<ThreadData<T>*>(args);
// ThreadPool<T>* threadpool = static_cast<ThreadPool<T>*>(args);
while(true)
{
T t;
{
// td->threadpool->threadlock();
lockGroud lockgroud(td->threadpool->Mutex()); //RAII
while(td->threadpool->threadempty()) //任务队列为空
{
td->threadpool->threadwait(); //线程就挂起等待
}
t = td->threadpool->pop(); //获取任务
// td->threadpool->threadunlock();
}
cout << td->_name << "获取任务，计算结果："<< t() << endl; //执行任务
// sleep(1);
}
return nullptr;
}
private:
int _num; //线程数量
vector<Thread*> _threads; //线程池
queue<T> _Task_queue; //任务队列
pthread_mutex_t _mutex; //互斥锁
pthread_cond_t _cond; //条件变量
};//main.cc
#include "ThreadPool.hpp"
#include <memory>
#include <unistd.h>
int main()
{
unique_ptr<ThreadPool<Task>> tp(new ThreadPool<Task>());
tp->run(); //线程先跑起来，等待任务的到来
int x,y;
char op;
while(true)
{
cout<< "请输入你要计算的内容"<< endl;
cout<< "格式如下：x+y" << endl<<">:";
cin >> x >> op >> y;
Task t(x,y,op,mymath); // 创建任务
tp->push(t); // 插入任务
sleep(1);
cout<< "---------------------------------------"<<endl;
}
return 0;
}
// 监控脚本指令->循环查看存在的线程
//while :; do ps -aL | grep Threadpool; sleep 1;echo "##################"; done上述代码只是一部分，线程封装的接口，任务的创建，以及锁的接口之前也都有写过，具体完整的代码自己查看吧：
lesson11/7_线程池 · 晚风不及你的笑/MyCodeStorehouse - 码云 - 开源中国 (gitee.com)
二、线程安全的单例模式
什么是单例模式
单例模式是一种 "经典的, 常用的, 常考的" 设计模式。
什么是设计模式
IT行业这么火, 涌入的人很多. 俗话说林子大了啥鸟都有. 大佬和菜鸡们两极分化的越来越严重. 为了让菜鸡们不太拖大佬的后腿, 于是大佬们针对一些经典的常见的场景, 给定了一些对应的解决方案, 这个就是 设计模式。
单例模式的特点
某些类, 只应该具有一个对象(实例), 就称之为单例。
在很多服务器开发场景中, 经常需要让服务器加载很多的数据 (上百G) 到内存中。此时往往要用一个单例的类来管理这些数据。
饿汉实现方式和懒汉实现方式
这个在之前的文章里有说过，感兴趣的可以去看一看：C++进阶 — 特殊类设计_晚风不及你的笑427的博客-CSDN博客
在这里我们对线程池的代码做一点小小的修改让其变成懒汉模式：构造私有，禁止拷贝构造和赋值重载实现，
//PthreadPool.hpp
#pragma once
#include "thread.hpp"
#include "lockGroud.hpp"
#include "Task.hpp"
#include <vector>
#include <queue>
#include <mutex>
#include <unistd.h>
using namespace ThreadNS;
static const int gnum = 5;
template<class T>
class ThreadPool;
template<class T>
class ThreadData //大号结构体，方便我们传入线程的名字，后续再想传入一些内容可以在此添加
{
public:
ThreadData(ThreadPool<T>* in,const string& name)
:threadpool(in),_name(name)
{}
public:
ThreadPool<T>* threadpool;
string _name;
};
template<class T>
class ThreadPool
{
public:
void push(const T& in)
{
// pthread_mutex_lock(&_mutex);
lockGroud lockgroud(&_mutex); //RAII的锁
_Task_queue.push(in); //给任务队列里插入任务
pthread_cond_signal(&_cond); //唤醒一个线程
// pthread_mutex_unlock(&_mutex);
}
void run()
{
for(auto& t:_threads)
{
//将要传入执行方法的参数打包成结构体传入
ThreadData<T>* td = new ThreadData<T>(this,t->threadname());
cout << t->threadname() << " 准备就绪" << endl;
t->start(handlerTask,td); //执行方法
}
}
~ThreadPool()
{
pthread_mutex_destroy(&_mutex); //销毁锁
pthread_cond_destroy(&_cond); //销毁条件变量
for(auto& t:_threads) delete t; //销毁线程
}
T pop()
{
T t = _Task_queue.front(); //取任务
_Task_queue.pop();
return t;
}
static ThreadPool<T>* GetInstance() //返回对象
{
if(nullptr == _tp)//双重判断，降低锁冲突的概率, 提高性能
{
_mtx.lock(); //使用互斥锁, 保证多线程情况下也只调用一次 new.
if(nullptr == _tp)
{
_tp = new ThreadPool<T>();
}
_mtx.unlock();
}
return _tp;
}
//一批接口
pthread_mutex_t* Mutex(){ return &_mutex;}
void threadlock() { pthread_mutex_lock(&_mutex); }
void threadunlock() { pthread_mutex_unlock(&_mutex); }
bool threadempty() { return _Task_queue.empty();}
void threadwait() { pthread_cond_wait(&_cond,&_mutex);}
private:
ThreadPool(const int& num = gnum)
:_num(num)
{
pthread_mutex_init(&_mutex,nullptr); //初始化锁
pthread_cond_init(&_cond,nullptr); //初始化条件变量
for(int i = 0;i<_num;++i)
{
_threads.push_back(new Thread()); //创建线程
}
}
ThreadPool(const T&) = delete;
void operator=(const T&) = delete;
static void* handlerTask(void* args)
{
ThreadData<T>* td = static_cast<ThreadData<T>*>(args);
// ThreadPool<T>* threadpool = static_cast<ThreadPool<T>*>(args);
while(true)
{
T t;
{
// td->threadpool->threadlock();
lockGroud lockgroud(td->threadpool->Mutex()); //RAII
while(td->threadpool->threadempty()) //任务队列为空
{
td->threadpool->threadwait(); //线程就挂起等待
}
t = td->threadpool->pop(); //获取任务
// td->threadpool->threadunlock();
}
cout << td->_name << "获取任务，计算结果："<< t() << endl; //执行任务
// sleep(1);
}
return nullptr;
}
private:
int _num; //线程数量
vector<Thread*> _threads; //线程池
queue<T> _Task_queue; //任务队列
pthread_mutex_t _mutex; //互斥锁
pthread_cond_t _cond; //条件变量
volatile static ThreadPool<T>* _tp;
static mutex _mtx;
};
template<class T>
ThreadPool<T>* ThreadPool<T>::_tp = nullptr;
template<class T>
mutex ThreadPool<T>::_mtx;//main.cc
#include "ThreadPool.hpp"
#include <memory>
#include <unistd.h>
int main()
{
// unique_ptr<ThreadPool<Task>> tp(new ThreadPool<Task>());
// tp->run(); //线程先跑起来，等待任务的到来
ThreadPool<Task>::GetInstance()->run();
int x,y;
char op;
while(true)
{
cout<< "请输入你要计算的内容"<< endl;
cout<< "格式如下：x+y" << endl<<">:";
cin >> x >> op >> y;
Task t(x,y,op,mymath); // 创建任务
// tp->push(t); // 插入任务
ThreadPool<Task>::GetInstance()->push(t);
sleep(1);
cout<< "---------------------------------------"<<endl;
}
return 0;
}
// 监控脚本指令->循环查看存在的线程
//while :; do ps -aL | grep Threadpool; sleep 1;echo "##################"; done
完整代码：lesson11/8_单例线程池 · 晚风不及你的笑/MyCodeStorehouse - 码云 - 开源中国 (gitee.com)
三、STL,智能指针和线程安全
STL中的容器是否是线程安全的?
不是。原因是, STL 的设计初衷是将性能挖掘到极致, 而一旦涉及到加锁保证线程安全, 会对性能造成巨大的影响.而且对于不同的容器, 加锁方式的不同, 性能可能也不同(例如hash表的锁表和锁桶)。因此 STL 默认不是线程安全。 如果需要在多线程环境下使用, 往往需要调用者自行保证线程安全。
智能指针是否是线程安全的?
对于 unique_ptr, 由于只是在当前代码块范围内生效, 因此不涉及线程安全问题。
对于 shared_ptr, 多个对象需要共用一个引用计数变量, 所以会存在线程安全问题. 但是标准库实现的时候考虑到了这个问题, 基于原子操作(CAS)的方式保证 shared_ptr 能够高效, 原子的操作引用计数.
四、其他常见的各种锁
- 悲观锁：在每次取数据时，总是担心数据会被其他线程修改，所以会在取数据前先加锁（读锁，写锁，行锁等），当其他线程想要访问数据时，被阻塞挂起。之前用的互斥锁就属于悲观锁
- 乐观锁：每次取数据时候，总是乐观的认为数据不会被其他线程修改，因此不上锁。但是在更新数据前，会判断其他数据在更新前有没有对数据进行修改。主要采用两种方式：版本号机制和CAS操作。
- CAS操作：当需要更新数据时，判断当前内存值和之前取得的值是否相等。如果相等则用新值更新。若不等则失败，失败则重试，一般是一个自旋的过程，即不断重试。
- 自旋锁：轮询式的去申请锁，直至申请成功。
这些锁的等待方式是不同的，是什么决定了最终的等待方式呢？是线程要等待的时长决定的。比如说一个线程申请到锁，访问临界资源的时间很长，那么就需要让其他线程挂起等待，如果访问时间很短，其他线程就可以用自旋的方式去等。如果不知道时间长短怎么决定等待方式呢？可以两种方式都用，分别测试一下，看哪个效率更高用哪个。
五、读者写者问题(了解)
读写锁
在编写多线程的时候，有一种情况是十分常见的。那就是，有些公共数据修改的机会比较少。相比较改写，它们读的机会反而高的多。通常而言，在读的过程中，往往伴随着查找的操作，中间耗时很长。给这种代码段加锁，会极大地降低我们程序的效率。那么有没有一种方法，可以专门处理这种多读少写的情况呢？ 有，那就是读写锁。 注：写独占，读共享，读锁优先级高
“321原则”
3种关系：写者和写者 -> 互斥 写者和读者 -> 互斥与同步 读者和读者 -> 没有关系
2种角色：读者和写者
1个交易场所：一段缓冲区
读者写者模型和生产消费模型的本质区别就是 消费者会拿走数据，而读者不会。
使用场景：一次发布，很长时间不做修改，大部分时间都是被读取的，比如写作，或者写博客。
读写锁接口
- 初始化
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,const pthread_rwlockattr_t* restrict attr);
- 销毁
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
- 加锁和解锁
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); //读者加锁
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock); //写者加锁
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock); //不论是读者还是写者，直接解锁
- 设置读写优先
int pthread_rwlockattr_setkind_np(pthread_rwlockattr_t *attr, int pref);
/*
pref 共有 3 种选择
PTHREAD_RWLOCK_PREFER_READER_NP (默认设置) 读者优先，可能会导致写者饥饿情况
PTHREAD_RWLOCK_PREFER_WRITER_NP 写者优先，目前有 BUG，导致表现行为和
PTHREAD_RWLOCK_PREFER_READER_NP 一致
PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP 写者优先，但写者不能递归加锁
*/
#include <vector>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
#include <pthread.h>
volatile int ticket = 1000;
pthread_rwlock_t rwlock;
void* reader(void* arg)
{
char* id = (char*)arg;
while (1) {
pthread_rwlock_rdlock(&rwlock);
if (ticket <= 0) {
pthread_rwlock_unlock(&rwlock);
break;
}
printf("%s: %d\n", id, ticket);
pthread_rwlock_unlock(&rwlock);
usleep(1);
}
return nullptr;
}
void* writer(void* arg)
{
char* id = (char*)arg;
while (1) {
pthread_rwlock_wrlock(&rwlock);
if (ticket <= 0) {
pthread_rwlock_unlock(&rwlock);
break;
}
printf("%s: %d\n", id, --ticket);
pthread_rwlock_unlock(&rwlock);
usleep(1);
}
return nullptr;
}
struct ThreadAttr
{
pthread_t tid;
std::string id;
};
std::string create_reader_id(std::size_t i)
{
// 利用 ostringstream 进行 string 拼接
std::ostringstream oss("thread reader ", std::ios_base::ate);
oss << i;
return oss.str();
}
std::string create_writer_id(std::size_t i)
{
// 利用 ostringstream 进行 string 拼接
std::ostringstream oss("thread writer ", std::ios_base::ate);
oss << i;
return oss.str();
}
void init_readers(std::vector<ThreadAttr>& vec)
{
for (std::size_t i = 0; i < vec.size(); ++i) {
vec[i].id = create_reader_id(i);
pthread_create(&vec[i].tid, nullptr, reader, (void*)vec[i].id.c_str());
}
}
void init_writers(std::vector<ThreadAttr>& vec)
{
for (std::size_t i = 0; i < vec.size(); ++i) {
vec[i].id = create_writer_id(i);
pthread_create(&vec[i].tid, nullptr, writer, (void*)vec[i].id.c_str());
}
}
void join_threads(std::vector<ThreadAttr> const& vec)
{
// 我们按创建的 逆序 来进行线程的回收
for (std::vector<ThreadAttr>::const_reverse_iterator it = vec.rbegin(); it !=
vec.rend(); ++it) {
pthread_t const& tid = it->tid;
pthread_join(tid, nullptr);
}
}
void init_rwlock()
{
#if 0 // 写优先
pthread_rwlockattr_t attr;
pthread_rwlockattr_init(&attr);
pthread_rwlockattr_setkind_np(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP);
pthread_rwlock_init(&rwlock, &attr);
pthread_rwlockattr_destroy(&attr);
#else // 读优先，会造成写饥饿
pthread_rwlock_init(&rwlock, nullptr);
#endif
}
int main()
{
// 测试效果不明显的情况下，可以加大 reader_nr
// 但也不能太大，超过一定阈值后系统就调度不了主线程了
const std::size_t reader_nr = 1000;
const std::size_t writer_nr = 2;
std::vector<ThreadAttr> readers(reader_nr);
std::vector<ThreadAttr> writers(writer_nr);
init_rwlock();
init_readers(readers);
init_writers(writers);
join_threads(writers);
join_threads(readers);
pthread_rwlock_destroy(&rwlock);
}
g++ -std=c++11 -Wall -Werror $^ -o $@ -lpthread
