本文深入解析信号量的工作原理及其在生产者与消费者模型中的应用，同时探讨线程池的设计与实现，包括线程池的作用、实现流程及代码示例。
文章目录
信号量:
功能:实现线程同步与互斥
本质:一个计数器(做资源计数-判断当前是否可以对临界资源进行操作)+等待队列+等待+唤醒
原理:
互斥原理:只具有0/1计数时,就可以实现互斥
初始计数为1,1表示当前只有一个进程可以获取资源,获取资源之后-1;临界资源操作完毕之后计数+1;并且唤醒等待队列上的线程;
计数为0,其他线程则进行等待
同步原理:对程序逻辑进行控制(对临界资源合理操作控制);通过计数判断当前是否能够对临界资源进行操作,不能操作(计数<=0),则等待;
其他线程促使条件满足后,对计数+1,唤醒等待的线程
条件变量实现同步与信号量的区别:
1.信号量并不需要搭配互斥锁的使用
2.信号量本身的计数就是是否能够对临界资源操作的判断条件,条件变量需要其他程序控制
实现流程:
1.定义信号量 sem_t
2.初始化信号量 int sem_init(sem_t *sem, int pshared, unsigned int value);
sem: 信号量变量
pshared: 0-用于线程间同步与互斥 !0-用于线程间同步与互斥
value: 信号量计数器初始值
3.判断计数是否可以对临界资源进行操作 int sem_wait(sem_t *sem)
sem: 信号量变量
对计数进行判断,如果>0,函数立即正确返回,返回前计数-1;程序流程继续向下可以操作临界资源,若<=0,则认为当前不能对临界资源进行操作,线程等待
4.计数+1,唤醒等待队列上的线程
5.销毁信号量 sem_destory(&sem)
需要用到的接口:
//包含的头文件 #include <semaphore.h>
int sem_wait(sem_t *sem); //计数<=0,一直等待(阻塞)
int sem_trywait(sem_t *sem); //计数<=0,立即报错返回
int sem_timedwait(sem_t *sem, struct timespec *abs_timeout);//等待时间超时后报错返回
int sem_post(sem_t *sem); //计数+1;促使其他线程操作条件满足,然后唤醒所有等待线程
使用信号量实现生产者与消费者模型:
write=(write+1)%capacity; //9之后+1变成10,取余10,变成0,回到起点
用idle_space表示剩余空间,利用信号量去判断是否满足操作条件
sem_wait(&idle_space) sem_wait(&lock)
写入之后先解锁 sem_post(&lock)
写入之后有数据空间计数+1; sem_post(&data_space)
代码示例：
#include<iostream>
#include<vector>
#include<pthread.h>
#include <semaphore.h>
#define MAX_QUEUE 10
using namespace std;
class RingQueue
{
public:
RingQueue(int capacity = MAX_QUEUE) :_capacity(capacity), _queue(capacity)
{
//int sem_init(sem_t *sem, int pshared, unsigned int value);
sem_init(&_lock, 0, 1);
sem_init(&_idle_space, 0, _capacity);
sem_init(&_data_space, 0, 0);
_write=0;
_read=0;
}
~RingQueue()
{
sem_destroy(&_lock);
sem_destroy(&_idle_space);
sem_destroy(&_data_space);
}
void PushData(int data)
{
//先判断是否满足操作条件，在加锁
sem_wait(&_idle_space);
sem_wait(&_lock);
_queue[_write]=data;
_write = (_write + 1) % _capacity;
//写完之后解锁
sem_post(&_lock);
//操作完毕唤醒消费者
sem_post(&_data_space);
}
void PopData(int& data)
{
//先判断是否满足操作条件，在加锁
sem_wait(&_data_space);
sem_wait(&_lock);
data=_queue[_read];
_read = (_read + 1) % _capacity;
sem_post(&_lock);
//操作完毕唤醒生产者
sem_post(&_idle_space);
}
private:
vector<int> _queue;
int _capacity;
int _read;
int _write;
sem_t _lock;
sem_t _idle_space;
sem_t _data_space;
};
void *thr_pro(void *arg)
{
RingQueue *q = (RingQueue*)arg;
int i = 0;
while (1)
{
cout << "pro put data: " << i << endl;
q->PushData(i++);
}
return NULL;
}
void *thr_con(void *arg)
{
RingQueue *q = (RingQueue*)arg;
while (1)
{
int data;
q->PopData(data);
cout << "con get data: " << data << endl;
}
return NULL;
}
int main()
{
RingQueue q;
pthread_t pro_tid[4],con_tid[4];
for (int i = 0; i < 4; ++i)
{
int ret = pthread_create(&pro_tid[i], NULL, thr_pro, (void*)&q);
if (ret != 0)
{
cout << "pthread creatr error" << endl;
return -1;
}
}
for (int i = 0; i < 4; ++i)
{
int ret = pthread_create(&con_tid[i], NULL, thr_con, (void*)&q);
if (ret != 0)
{
cout << "pthread creatr error" << endl;
return -1;
}
}
for (int i = 0; i < 4; ++i)
{
pthread_join(pro_tid[i], NULL);
}
for (int i = 0; i < 4; ++i)
{
pthread_join(con_tid[i], NULL);
}
return 0;
}
线程池
至少一个线程+任务队列
在程序初始化时,创建固定数量的线程(最大数量限制),从任务队列中获取任务,进行处理
作用:
1.避免为大量请求创建线程,导致瞬间资源耗尽程序崩溃
2.避免线程大量创建销毁所带来的时间成本
线程池的实现:
线程的创建+线程安全的任务队列实现
1.任务类的实现
2.线程池类的实现
class ThreadPool
{
private:
int thr_max;//最大线程数量
queue<Task> _task_queue;//任务队列
pthread_mutex_t mutex;
pthread_cond_t pro_cond;
pthread_cond_t con_cond;
};
3.将队列的加锁和解锁操作封装起来
4.将条件变量的等待和唤醒也封装起来
5.主函数中创建线程池,然后初始化,循环放入任务
6.线程池的退出(所有线程退出后---加入_quit_flag标记,初始化为false)
成员变量中加入_cur_thr//表示当前线程数量
_quit_flag标记为true时,唤醒所有线程,准备退出
线程陷入等待之前,先判断是否用户要销毁线程池(此处对临界资源判断,要加锁)
if(_quit_flag==true)
{
_cur_thr--;
pthread_mutex_unlock(&mutex);
pthread_exit(NULL);
}
Q:线程的创建为什么不放在构造函数里?
A:因为构造函数没有返回值判断(不知道到底创建线程成功与否)
代码示例:
#include<iostream>
#include<queue>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>
using namespace std;
typedef void(*handler_t)(int data);
#define MAX_THR 5
class Task
{
public:
void SetTask(int data,handler_t handler)
{
_data=data;
_handler=handler;
}
void Run()
{
_handler(_data);
}
private:
int _data;
handler_t _handler;
};
class ThreadPool
{
public:
ThreadPool(int max=MAX_THR):thr_max(max),_cur_thr(max),_quit_flag(false)
{
pthread_mutex_init(&mutex,NULL);
pthread_cond_init(&pro_cond,NULL);
pthread_cond_init(&con_cond,NULL);
}
~ThreadPool()
{
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&pro_cond);
pthread_cond_destroy(&con_cond);
}
int PoolInit()
{
pthread_t tid;
for(int i=0;i<thr_max;++i)
{
int ret=pthread_create(&tid,NULL,thr_start,(void*)this);
if(ret!=0)
{
cout<<"pthread create error"<<endl;
return -1;
}
pthread_detach(tid);
}
}
void TaskPush(Task& t)
{
QueueBlock();
_task_queue.push(t);
ConsumerWakeUp();
QueueUnBlock();
}
void TaskPop(Task& t)
{
t = _task_queue.front();
_task_queue.pop();
}
static void* thr_start(void* arg)
{
ThreadPool* pool=(ThreadPool*)arg;
while(1)
{
pool->QueueUnBlock();
while(pool->QueueEmpty())
{
pool->ConsumerWait();
}
Task t;
pool->TaskPop(t);
pool->QueueUnBlock();
t.Run();
}
}
void PoolQuit()
{
QueueBlock();
if(_quit_flag==false)
{
_quit_flag=true;
}
QueueUnBlock();
while(_cur_thr>0)
{
ConsumerBroadCast();
usleep(1000);
}
}
void QueueBlock()
{
pthread_mutex_lock(&mutex);
}
void QueueUnBlock()
{
pthread_mutex_unlock(&mutex);
}
void ConsumerWait()
{
//先判断用户是否要销毁线程池
if(_quit_flag==true)
{
_cur_thr--;
pthread_mutex_unlock(&mutex);
cout<<pthread_self()<<" "<<"exit!"<<endl;
pthread_exit(NULL);
}
pthread_cond_wait(&con_cond,&mutex);
}
void ConsumerWakeUp()
{
pthread_cond_signal(&con_cond);
}
void ConsumerBroadCast()
{
pthread_cond_broadcast(&con_cond);
}
bool QueueEmpty()
{
if(_task_queue.empty()==true)
{
return true;
}
return false;
}
private:
int thr_max;//最大线程数量
queue<Task> _task_queue;//任务队列
pthread_mutex_t mutex;
pthread_cond_t pro_cond;
pthread_cond_t con_cond;
bool _quit_flag;//进程池是否销毁的标志
int _cur_thr;//表示当前进程数量
};
void thr_handle(int data)
{
srand(time(NULL));
int second=rand()%5;
cout<<"thr:"<<pthread_self()<<' '<<"get data:"<<data<<' '<<"sleep:"<<second<<endl;
sleep(second);
}
int main()
{
ThreadPool pool;
pool.PoolInit();
for(int i=0;i<10;++i)
{
Task task;
task.SetTask(i,thr_handle);
pool.TaskPush(task);
}
pool.PoolQuit();
return 0;
}
线程安全的单例模式:
设计模式:大佬们针对典型的应用场景设计出的解决方案
工厂模式:封装对象的产生过程
单例模式:是设计模式中的一种常见模式,一个对象只能被实例化一次(一个资源只被加载一次)
单例模式的实现:
饿汉方式:资源总是提前准备好—资源在初始化时进行加载
懒汉方式:资源在需要用的时候才加载,在多个执行流中就可能被加载多次,因此资源的加载/对象的实例化需要受保护(使用互斥锁保护)
单例模式的优缺点:
优点:完全打开程序之后运行流畅
缺点:程序初始化时资源加载时间较长
class Info
{
static T* data;
T* getdata()
{
pthread_mutex_lock(&mutex);
if(data==NULL)
{
data=new T ();
}
pthread_mutex_unlock(&mutex);
return _data;
}
};
可以理解为智能指针就是线程安全的
读写锁:
//我在画黑板报的时候,别人不但不可以画,我也不让别人看
写互斥:一个线程在写的时候,别的线程既不可以写也不可以读
//我写完了别人可以看,而且可以同时很多人看
读共享:多个读数据线程可以同时读取
实现原理:
write_count 、read_count
加写锁的时候判断读者计数和写者计数都为0才能加锁
加读锁的时候只需要判断写者计数为0就可以加锁
读写锁中可能因为读者过多—循环加锁,导致写锁一直加不上;为了避免这种情况,所有读写锁是有优先级的
写锁优先:
加写锁的时候,读者计数如果>0,这时候会拒绝后续加读锁的操作,当当前读者解锁之后,读者计数为0时,加写锁
读写锁中默认的是读锁优先;
读写锁无法加锁时,读写锁的等待是自旋等待,使用自旋锁实现;
自旋锁:
循环对条件进行判断,并不进入挂起等待
应用场景:操作时间比较短的等待
优缺点:
优点:等待的唤醒/调用的返回更加实时
缺点:cpu资源消耗较高(一直循环判断)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
