yssemaphore.h

电力故障信息采集,主要是针对南自的保护装置,这个程序用在Linux操作系统下

#ifndef YSSEMAPHORE_H
#define YSSEMAPHORE_H
#include "ysheader.h"
///////////////////////////////信号量常量////////////////////////////////////////
////本系统预留使用5个信号量用于进程级锁
#define 		SM_SENDCTRL					0 	//发送数据控制信号量
#define 		SM_RECVCTRL					1 	//接收数据控制信号量
#define 		SM_USER1					2 	//备用控制信号量
#define 		SM_USER2					3 	//备用控制信号量
#define 		SM_USER3					4 	//备用控制信号量
#define 		SM_USER4					5 	//备用控制信号量
////系统产生全局10个本地锁

#define 		SM_SENDQUEUE				0 	//显示队列访问控制信号量
#define 		SM_RECVQUEUE				1 	//显示队列访问控制信号量
#define 		SM_DISPQUEUE					2 	//显示队列访问控制信号量
#define 		SM_OUTBUF					3 	//显示队列访问控制信号量
#define 		SM_ACCESSDB					4 	//显示队列访问控制信号量

//*********************信号量类的定义*****************//
#define SEMMSL  						100
#define SEM_RESOURCE_MAX					1
union semun
{
    int val;
    struct semid_ds *buf;
    ushort *array;
};
	
class CSemaphore
{
    public:
    CSemaphore()
    {
	m_SemaphoreQid=0;
	m_key=0;
    }
    
    ~CSemaphore()
    {
	//删除信号集
	if(m_SemaphoreQid>0)
	    semctl(m_SemaphoreQid,0,IPC_RMID,0);
    }
    public:
    int m_SemaphoreQid;						//信号量qid
    key_t	m_key;
    public:
    int Create_Semaphore(key_t keyid,int members)		//创建一个信号量集
    {
	int sid;
	union semun semopts;
	m_key=keyid;
	if(members > SEMMSL)
	{
	    return -1;
	}
	if((sid=semget(keyid,members,IPC_CREAT|IPC_EXCL|0666))==-1)
	{
	    sid=Open_Semaphore(keyid);
	    if(sid==-1)
	    {
		printf("====================error:%d;%d;%d\n",keyid,members,sid);
		return -1;
	    }
	}
	semopts.val=SEM_RESOURCE_MAX;
	for(int i=0;i<members;i++)
	    semctl(sid,i,SETVAL,semopts);
	m_SemaphoreQid=sid;
	return sid;
    }
    
    int Open_Semaphore(key_t key)				//打开一个信号量集
    {
	int sid=semget(key,0,0666);
	if(sid==-1) return -1;
	return sid;
    }
    
    int Open_Semaphore()					//打开一个信号量集
    {
	int sid=semget(m_key,0,0666);
	m_SemaphoreQid=sid;
	return sid;
    }
    
    bool locksem(int sid,int member,int blockflag)
    {
	struct sembuf sem_lock;
	sem_lock.sem_num=0;sem_lock.sem_op=-1;
	//sem_lock.sem_flg|=SEM_UNDO;
	if(blockflag!=1)
	    sem_lock.sem_flg|=IPC_NOWAIT;
	if(member<0||member>(get_member_count(sid)-1))
	    return 0;
	//if(!getval(sid,member)) return 0;
	sem_lock.sem_num=member;
	if((semop(sid,&sem_lock,1))==-1) return 0;
	return 1;
    }
    
    bool locksem(int member,int blockflag=0)
    {
	if(m_SemaphoreQid<=0) return 0;
	struct sembuf sem_lock;
	sem_lock.sem_num=member;sem_lock.sem_op=-1;
	sem_lock.sem_flg|=SEM_UNDO;
	if(blockflag!=1)
	    sem_lock.sem_flg|=IPC_NOWAIT;
	if(member<0||member>(get_member_count(m_SemaphoreQid)-1))
	    return 0;
	//if(!getval(m_SemaphoreQid,member)) return 0;
	sem_lock.sem_num=member;
	if((semop(m_SemaphoreQid,&sem_lock,1))==-1) return 0;
	printf("--lock:--------------%d\n",getval(member));
	return 1;
    }
    
    bool unlocksem(int sid,int member)
    {
	struct sembuf sem_unlock={member,1,SEM_UNDO|IPC_NOWAIT};
	int semval;
	if(member<0||member>(get_member_count(sid)-1)) return 0;
	semval=getval(sid,member);
	//if(semval==SEM_RESOURCE_MAX) return 0;
	sem_unlock.sem_num=member;
	if((semop(sid,&sem_unlock,1))==-1) return 0;
	return 1;
    }
    
    bool unlocksem(int member)
    {
	if(m_SemaphoreQid<=0) return 0;
	struct sembuf sem_unlock={member,1,SEM_UNDO};
	int semval;
	if(member<0||member>(get_member_count(m_SemaphoreQid)-1)) return 0;
	semval=getval(m_SemaphoreQid,member);
	//if(semval==SEM_RESOURCE_MAX) return 0;
	sem_unlock.sem_num=member;
	if((semop(m_SemaphoreQid,&sem_unlock,1))==-1) return 0;
	printf("---unlock-------------%d\n",getval(member));
	return 1;
    }
    
    bool removesem(int sid)
    {
	semctl(sid,0,IPC_RMID,0);
	return 1;
    }
    
    bool removesem()
    {
	if(m_SemaphoreQid<=0) return 0;
	semctl(m_SemaphoreQid,0,IPC_RMID,0);
	return 1;
    }
    
    int get_member_count(int sid)
    {
	union semun semopts;
	struct semid_ds mysemds;
	semopts.buf=&mysemds;
	int rc=semctl(sid,0,IPC_STAT,semopts);
	if(rc==-1) return -1;
	return (int)semopts.buf->sem_nsems;
    }
    
    int get_member_count()
    {
	if(m_SemaphoreQid<=0) return -1;
	union semun semopts;
	struct semid_ds mysemds;
	semopts.buf=&mysemds;
	int rc=semctl(m_SemaphoreQid,0,IPC_STAT,semopts);
	if(rc==-1) return -1;
	return (int)semopts.buf->sem_nsems;
    }
    
    int getval(int sid,int member)
    {
	int rc=semctl(sid,member,GETVAL);
	return rc;
    }
    
    int getval(int member)
    {
	if(m_SemaphoreQid<=0) return -1;
	int rc=semctl(m_SemaphoreQid,member,GETVAL);
	return rc;
    }
    
    void changemode(int sid,char* mode)
    {
	int rc=-1;
	union semun semopts;
	struct semid_ds mysemds;
	semopts.buf=&mysemds;
	rc=semctl(sid,0,IPC_STAT,semopts);
	if(rc==-1) return;
	sscanf(mode,"%ho",&semopts.buf->sem_perm.mode);
	semctl(sid,0,IPC_SET,semopts);
	return;
    }
    
    void changemode(char* mode)
    {
	if(m_SemaphoreQid<=0) return ;
	int rc=-1;
	union semun semopts;
	struct semid_ds mysemds;
	semopts.buf=&mysemds;
	rc=semctl(m_SemaphoreQid,0,IPC_STAT,semopts);
	if(rc==-1) return;
	sscanf(mode,"%ho",&semopts.buf->sem_perm.mode);
	semctl(m_SemaphoreQid,0,IPC_SET,semopts);
	return;
    }
};

class CSemLocker
{
    public:
    CSemLocker(CSemaphore &sem,int member=0,bool bBlock=TRUE)
    {
	m_semlock=&sem;
	m_member=member;
	m_semlock->locksem(member,(int)bBlock);
    }
    
    ~CSemLocker()
    {
	if(m_semlock)
	    m_semlock->unlocksem(m_member);
    }
    
    private:
    CSemaphore* m_semlock;
    int 		  m_member;
    public:
    CSemaphore* GetSemaphore()
    {
	return m_semlock;
    }
};

#endif