msgdequeue.h
本例示范Linux信号量的基本用法。
该范例使用了两个线程分别对一个公用队列进行入队和出队操作,
并用信号量进行控制,当队列空时出队操作可以被阻塞,
当队列满时入队操作可以被阻塞。
主要用到的信号量函数有:
sem_init:初始化信号量sem_t,初始化的时候可以指定信号量的初始值,以及是否可以在多进程间共享。
sem_wait:一直阻塞等待直到信号量>0。
sem_timedwait:阻塞等待若干时间直到信号量>0。
sem_post:使信号量加1。
sem_destroy:释放信号量。和sem_init对应。
关于各函数的具体参数请用man查看。如man sem_init可查看该函数的帮助。
下面看具体的代码:
//--------------------------msgdequeue.h开始-------------------------------------
//实现可控队列
#ifndef MSGDEQUEUE_H
#define MSGDEQUEUE_H
#include "tmutex.h"
#include <iostream>
#include <errno.h>
#include <time.h>
#include <semaphore.h>
#include <deque>
using namespace std;
template<typename T,typename MUTEX_TYPE = ThreadMutex>
class CMessageDequeue
{
public:
CMessageDequeue(size_t MaxSize) : m_MaxSize( MaxSize ){
sem_init( &m_enques,0, m_MaxSize ); //入队信号量初始化为MaxSize,最多可容纳MaxSize各元素
sem_init( &m_deques,0,0 ); //队列刚开始为空,出队信号量初始为0
}
~CMessageDequeue(){
sem_destroy(&m_enques);
sem_destroy(&m_deques);
}
int sem_wait_i( sem_t *psem, int mswait ){
//等待信号量变成>0,mswait为等待时间,若mswait<0则无穷等待,否则等待若干mswait毫秒。
if( mswait < 0 ){
int rv = 0;
while( ((rv = sem_wait(psem) ) != 0 ) && (errno == EINTR ) ); //等待信号量,errno==EINTR屏蔽其他信号事件引起的等待中断
return rv;
}else{
timespec ts;
clock_gettime(CLOCK_REALTIME, &ts ); //获取当前时间
ts.tv_sec += (mswait / 1000 ); //加上等待时间的秒数
ts.tv_nsec += ( mswait % 1000 ) * 1000; //加上等待时间纳秒数
int rv = 0;
while( ((rv=sem_timedwait( psem, &ts ))!=0) && (errno == EINTR) ); //等待信号量,errno==EINTR屏蔽其他信号事件引起的等待中断
return rv;
}
}
bool push_back( const T &item, int mswait = -1 ){
//等待mswait毫秒直到将item插入队列,mswait为-1则一直等待
if( -1 == sem_wait_i( &m_enques, mswait )){
return false;
}
//AUTO_GUARD:定界加锁,见Linux多线程及临界区编程例解的tmutex.h文件定义。
AUTO_GUARD( g, MUTEX_TYPE, m_lock );
try{
m_data.push_back( item );
cout << "push " << item << endl;
sem_post( &m_deques );
return true;
}catch(){
return false;
}
}
bool pop_front( T &item, bool bpop = true, int mswait = -1 ){
//等待mswait毫秒直到从队列取出元素,mswait为-1则一直等待
if( -1 == sem_wait_i( &m_deques, mswait ) ){
return false;
}
//AUTO_GUARD:定界加锁,见Linux多线程及临界区编程例解的tmutex.h文件定义。
AUTO_GUARD( g, MUTEX_TYPE, m_lock );
try{
item = m_data.front();
if( bpop ){
m_data.pop_front();
cout << "pop " << item << endl;
}
sem_post( &m_enques );
return true;
}catch(){
return false;
}
}
inline size_t size(){
return m_data.size();
}
private:
MUTEX_TYPE m_lock;
deque<T> m_data;
size_t m_MaxSize;
sem_t m_enques;
sem_t m_deques;
};
#endif
#include "msgdequeue.h"
#include <pthread.h>
#include <iostream>
using namespace std;
CMessageDequeue<int> qq(5);
void *get_thread(void *parg);
void *put_thread(void *parg);
void *get_thread(void *parg){
while(true){
int a = -1;
if( !qq.pop_front( a,true, 1000 ) ){
cout << "pop failed. size=" << qq.size() <<endl;
}
}
return NULL;
}
void *put_thread(void *parg){
for(int i=1; i<=30; i++){
qq.push_back( i, -1 );
}
return NULL;
}
int main()
{
pthread_t pget,pput;
pthread_create( &pget,NULL,get_thread,NULL);
pthread_create( &pput, NULL, put_thread,NULL);
pthread_join( pget,NULL ); pthread_join( pput,NULL );
return 0;
}
tmutex.h
#ifndef TMUTEX_H
#define TMUTEX_H
#include <pthread.h>
//线程互斥量
struct ThreadMutex
{
ThreadMutex()
{
pthread_mutex_init(&mtx,NULL);
}
~ThreadMutex()
{
pthread_mutex_destroy( &mtx );
}
inline void lock()
{
pthread_mutex_lock( &mtx );
}
inline void unlock()
{
pthread_mutex_unlock( &mtx );
}
pthread_mutex_t mtx;
};
//空互斥量,即调用lock时什么事都不做。
struct NullMutex
{
inline void lock()
{
}
inline void unlock()
{
}
};
template<class T>
class CAutoGuard
{
public:
CAutoGuard(T &mtx) : m_mtx(mtx)
{
m_mtx.lock();
}
~CAutoGuard()
{
m_mtx.unlock();
}
protected:
T &m_mtx;
};
#define AUTO_GUARD( guard_tmp_var, MUTEX_TYPE, mtx )
CAutoGuard<MUTEX_TYPE> guard_tmp_var(mtx)
#endif
本例示范Linux信号量的基本用法。
该范例使用了两个线程分别对一个公用队列进行入队和出队操作,
并用信号量进行控制,当队列空时出队操作可以被阻塞,
当队列满时入队操作可以被阻塞。
主要用到的信号量函数有:
sem_init:初始化信号量sem_t,初始化的时候可以指定信号量的初始值,以及是否可以在多进程间共享。
sem_wait:一直阻塞等待直到信号量>0。
sem_timedwait:阻塞等待若干时间直到信号量>0。
sem_post:使信号量加1。
sem_destroy:释放信号量。和sem_init对应。
关于各函数的具体参数请用man查看。如man sem_init可查看该函数的帮助。
下面看具体的代码:
//--------------------------msgdequeue.h开始-------------------------------------
//实现可控队列
#ifndef MSGDEQUEUE_H
#define MSGDEQUEUE_H
#include "tmutex.h"
#include <iostream>
#include <errno.h>
#include <time.h>
#include <semaphore.h>
#include <deque>
using namespace std;
template<typename T,typename MUTEX_TYPE = ThreadMutex>
class CMessageDequeue
{
public:
CMessageDequeue(size_t MaxSize) : m_MaxSize( MaxSize ){
sem_init( &m_enques,0, m_MaxSize ); //入队信号量初始化为MaxSize,最多可容纳MaxSize各元素
sem_init( &m_deques,0,0 ); //队列刚开始为空,出队信号量初始为0
}
~CMessageDequeue(){
sem_destroy(&m_enques);
sem_destroy(&m_deques);
}
int sem_wait_i( sem_t *psem, int mswait ){
//等待信号量变成>0,mswait为等待时间,若mswait<0则无穷等待,否则等待若干mswait毫秒。
if( mswait < 0 ){
int rv = 0;
while( ((rv = sem_wait(psem) ) != 0 ) && (errno == EINTR ) ); //等待信号量,errno==EINTR屏蔽其他信号事件引起的等待中断
return rv;
}else{
timespec ts;
clock_gettime(CLOCK_REALTIME, &ts ); //获取当前时间
ts.tv_sec += (mswait / 1000 ); //加上等待时间的秒数
ts.tv_nsec += ( mswait % 1000 ) * 1000; //加上等待时间纳秒数
int rv = 0;
while( ((rv=sem_timedwait( psem, &ts ))!=0) && (errno == EINTR) ); //等待信号量,errno==EINTR屏蔽其他信号事件引起的等待中断
return rv;
}
}
bool push_back( const T &item, int mswait = -1 ){
//等待mswait毫秒直到将item插入队列,mswait为-1则一直等待
if( -1 == sem_wait_i( &m_enques, mswait )){
return false;
}
//AUTO_GUARD:定界加锁,见Linux多线程及临界区编程例解的tmutex.h文件定义。
AUTO_GUARD( g, MUTEX_TYPE, m_lock );
try{
m_data.push_back( item );
cout << "push " << item << endl;
sem_post( &m_deques );
return true;
}catch(){
return false;
}
}
bool pop_front( T &item, bool bpop = true, int mswait = -1 ){
//等待mswait毫秒直到从队列取出元素,mswait为-1则一直等待
if( -1 == sem_wait_i( &m_deques, mswait ) ){
return false;
}
//AUTO_GUARD:定界加锁,见Linux多线程及临界区编程例解的tmutex.h文件定义。
AUTO_GUARD( g, MUTEX_TYPE, m_lock );
try{
item = m_data.front();
if( bpop ){
m_data.pop_front();
cout << "pop " << item << endl;
}
sem_post( &m_enques );
return true;
}catch(){
return false;
}
}
inline size_t size(){
return m_data.size();
}
private:
MUTEX_TYPE m_lock;
deque<T> m_data;
size_t m_MaxSize;
sem_t m_enques;
sem_t m_deques;
};
#endif
#include "msgdequeue.h"
#include <pthread.h>
#include <iostream>
using namespace std;
CMessageDequeue<int> qq(5);
void *get_thread(void *parg);
void *put_thread(void *parg);
void *get_thread(void *parg){
while(true){
int a = -1;
if( !qq.pop_front( a,true, 1000 ) ){
cout << "pop failed. size=" << qq.size() <<endl;
}
}
return NULL;
}
void *put_thread(void *parg){
for(int i=1; i<=30; i++){
qq.push_back( i, -1 );
}
return NULL;
}
int main()
{
pthread_t pget,pput;
pthread_create( &pget,NULL,get_thread,NULL);
pthread_create( &pput, NULL, put_thread,NULL);
pthread_join( pget,NULL ); pthread_join( pput,NULL );
return 0;
}
tmutex.h
#ifndef TMUTEX_H
#define TMUTEX_H
#include <pthread.h>
//线程互斥量
struct ThreadMutex
{
ThreadMutex()
{
pthread_mutex_init(&mtx,NULL);
}
~ThreadMutex()
{
pthread_mutex_destroy( &mtx );
}
inline void lock()
{
pthread_mutex_lock( &mtx );
}
inline void unlock()
{
pthread_mutex_unlock( &mtx );
}
pthread_mutex_t mtx;
};
//空互斥量,即调用lock时什么事都不做。
struct NullMutex
{
inline void lock()
{
}
inline void unlock()
{
}
};
template<class T>
class CAutoGuard
{
public:
CAutoGuard(T &mtx) : m_mtx(mtx)
{
m_mtx.lock();
}
~CAutoGuard()
{
m_mtx.unlock();
}
protected:
T &m_mtx;
};
#define AUTO_GUARD( guard_tmp_var, MUTEX_TYPE, mtx )
CAutoGuard<MUTEX_TYPE> guard_tmp_var(mtx)
#endif