Posic lock API使用

最新推荐文章于 2019-08-22 10:55:17 发布

qingtianhit

最新推荐文章于 2019-08-22 10:55:17 发布

阅读量398

点赞数

本文链接：https://blog.csdn.net/qingtianhit/article/details/50039579

版权

都是早些年写的代码了，发上来做个纪念...

/********************************************************************

* Copyright
* All rights reserved
*
* 文件名称: posix_lock.h
* 文件标示:
* 摘要: 基于 posix 实现的锁
* 线程安全: 是
*
* 当前版本: 1.0
* 作者:
* 完成日期: 2010-9-8 10:12:09
*
* 备注
********************************************************************/
#ifndef _POSIX_LOCK_H_
#define _POSIX_LOCK_H_

#include "basic.h"
#include "posix_ipcs.h"

//互斥锁
class CLock
{
public:
CLock();
~CLock();

bool Lock(); //互斥量加锁阻塞方式
bool UnLock(); //互斥量解锁
bool TimedLock(int iMilliSeconds ); //超时加锁单位MS

protected:
private:
CLock(const CLock&); //拷贝构造函数
const CLock& operator= (const CLock&); //拷贝赋值函数

pthread_mutex_t m_mtMtx;
};

//命名锁(基于共享内存)
class CNamedLock
{
public:
CNamedLock(const char * pszLockName);
~CNamedLock();

bool Create(); //初始化共享内存锁
bool Attach(); //关联
bool Lock(); //互斥量加锁阻塞方式
bool UnLock(); //互斥量解锁
bool TimedLock(int iMilliSeconds ); //超时加锁单位MS
bool Remove(); //删除命名锁

protected:
private:
CNamedLock(const CNamedLock&); //拷贝构造函数
const CNamedLock& operator= (const CNamedLock&); //拷贝赋值函数

pthread_mutex_t * m_pMtx;
string m_strLockName;
};

//读写锁
class CRdWtLock
{
public:
CRdWtLock();
~CRdWtLock();

bool ReadLock(); //加读锁阻塞方式
bool WriteLock(); //加读锁阻塞方式
bool UnLock(); //解锁

bool TimedReadLock(int iMilliSeconds ); //超时加读锁单位MS
bool TimedWriteLock(int iMilliSeconds ); //超时加读锁单位MS
protected:
private:
CRdWtLock(const CRdWtLock&); //拷贝构造函数
const CRdWtLock& operator= (const CRdWtLock&); //拷贝赋值函数

pthread_rwlock_t m_rwLock;
};

//命名读写锁
class CNamedRdWtLock
{
public:
CNamedRdWtLock(const char * pszLockName);
~CNamedRdWtLock();

bool Create(); //初始化共享内存锁
bool Attach(); //关联
bool ReadLock(); //加读锁阻塞方式
bool WriteLock(); //加读锁阻塞方式
bool UnLock(); //解锁

bool TimedReadLock(int iMilliSeconds ); //超时加读锁单位MS
bool TimedWriteLock(int iMilliSeconds ); //超时加读锁单位MS
bool Remove(); //删除命名锁
protected:
private:
CNamedRdWtLock(const CNamedRdWtLock&); //拷贝构造函数
const CNamedRdWtLock& operator= (const CNamedRdWtLock&); //拷贝赋值函数

pthread_rwlock_t * m_prwLock;
string m_strLockName;
};

#endif

--------------------------------------------------------- 分割线---------------------------------------------------------------

/********************************************************************
* Copyright
* All rights reserved
*
* 文件名称: posix_lock.cpp
* 文件标示:
* 摘要: 基于 posix 实现的锁
* 线程安全: 是
*
* 当前版本: 1.0
* 作者:
* 完成日期: 2011-2-21 16:56:49
*
* 备注
如果不设置 PTHREAD_PROCESS_SHARED 则命名类锁的结果是不确定的
********************************************************************/
#include "posix_lock.h"

/*****************************普通的锁*********************************/
/*
功能: 构造带属性的mutex
参数:
返回:
*/
CLock::CLock()
{
pthread_mutex_init(&m_mtMtx,NULL);
}
/*
功能: 析构函数
参数:
返回:
*/
CLock::~CLock()
{
pthread_mutex_destroy(&m_mtMtx);
}
/*
功能: 互斥量加锁阻塞方式
参数:
无
返回:
bool 成功
false 失败
*/
bool CLock::Lock()
{
int iRet = -1;

iRet = pthread_mutex_lock(&m_mtMtx);
if (iRet != 0)
{
return false;
}

return true;
}
/*
功能: 互斥量解锁
参数:
返回:
true 成功
false 失败
*/
bool CLock::UnLock()
{
int iRet = 0 ;

iRet = pthread_mutex_unlock(&m_mtMtx);
if(iRet != 0)
{
return false;
}

return true;
}
/*
功能: 互斥量加锁阻塞方式
参数:
int iMilliSeconds[in] 超时时间单位ms
返回:
bool 成功
false 失败
*/
bool CLock::TimedLock(int iMilliSeconds)
{
int iRet = -1;
struct timespec timewake;

CDateTimeH::AbsTimeFromNow(iMilliSeconds,&timewake);

iRet = pthread_mutex_timedlock(&m_mtMtx,&timewake);
if (iRet != 0)
{
return false;
}

return true;
}

/*****************************普通的锁*********************************/

/*****************************命名锁*********************************/
/*
功能: 构造带属性的mutex
参数:
返回:
*/
CNamedLock::CNamedLock(const char * pszLockName)
:m_strLockName(string(pszLockName) + string(".lock")),m_pMtx(NULL)
{

}
/*
功能: 析构函数
参数:
返回:
*/
CNamedLock::~CNamedLock()
{
//析构的时候不能销毁资源
}
/*
功能: 初始化锁
参数:
无
返回:
bool 成功
false 失败
*/
bool CNamedLock::Create()
{
CPosixShm Shm(m_strLockName.c_str());
pthread_mutexattr_t mtMtxAttr;

m_pMtx = (pthread_mutex_t *)Shm.Alloc(sizeof(pthread_mutex_t));
if (m_pMtx == NULL)
{
return false;
}
pthread_mutexattr_init(&mtMtxAttr);
pthread_mutexattr_setpshared(&mtMtxAttr,PTHREAD_PROCESS_SHARED);
pthread_mutex_init(m_pMtx,&mtMtxAttr);

return true;
}
/*
功能: 关联锁的共享内存
参数:
无
返回:
bool 成功
false 失败
*/
bool CNamedLock::Attach()
{
CPosixShm Shm(m_strLockName.c_str());

if (!Shm.Attach())
{
return false;
}
m_pMtx = (pthread_mutex_t *)Shm.GetShmPoint();
if (m_pMtx == NULL)
{
return false;
}
return true;
}

/*
功能: 互斥量加锁阻塞方式
参数:
无
返回:
bool 成功
false 失败
*/
bool CNamedLock::Lock()
{
int iRet = -1;

if (m_pMtx == NULL)
{
return false;
}
iRet = pthread_mutex_lock(m_pMtx);
if (iRet != 0)
{
return false;
}

return true;
}
/*
功能: 互斥量解锁
参数:
返回:
true 成功
false 失败
*/
bool CNamedLock::UnLock()
{
int iRet = 0 ;

if (m_pMtx == NULL)
{
return false;
}
iRet = pthread_mutex_unlock(m_pMtx);
if(iRet != 0)
{
return false;
}

return true;
}
/*
功能: 互斥量加锁阻塞方式
参数:
int iMilliSeconds[in] 超时时间单位ms
返回:
bool 成功
false 失败
*/
bool CNamedLock::TimedLock(int iMilliSeconds)
{
int iRet = -1;
struct timespec timewake;

if (m_pMtx == NULL)
{
return false;
}

CDateTimeH::AbsTimeFromNow(iMilliSeconds,&timewake);

iRet = pthread_mutex_timedlock(m_pMtx,&timewake);
if (iRet != 0)
{
return false;
}

return true;
}
/*
功能: 删除共享内存中的命名锁
参数:
无
返回:
bool 成功
false 失败
*/
bool CNamedLock::Remove()
{
CPosixShm Shm(m_strLockName.c_str());

if (!Shm.Attach())
{
return false;
}

return Shm.Remove();

}

/*****************************命名锁*********************************/

/*****************************普通读写锁*********************************/
/*
功能: 构造带属性的mutex
参数:
返回:
*/
CRdWtLock::CRdWtLock()
{
pthread_rwlock_init(&m_rwLock,NULL);
}
/*
功能: 析构函数
参数:
返回:
*/
CRdWtLock::~CRdWtLock()
{
pthread_rwlock_destroy(&m_rwLock);
}
/*
功能: 加读锁
参数:
无
返回:
bool 成功
false 失败
*/
bool CRdWtLock::ReadLock()
{
int iRet = -1;

iRet = pthread_rwlock_rdlock(&m_rwLock);
if (iRet != 0)
{
return false;
}

return true;
}

/*
功能: 加写锁
参数:
无
返回:
bool 成功
false 失败
*/
bool CRdWtLock::WriteLock()
{
int iRet = -1;

iRet = pthread_rwlock_wrlock(&m_rwLock);
if (iRet != 0)
{
return false;
}

return true;
}

/*
功能: 带超时的读锁
参数:
int iMilliSeconds[in] 超时时间单位ms
返回:
bool 成功
false 失败
*/
bool CRdWtLock::TimedReadLock(int iMilliSeconds)
{
int iRet = -1;
struct timespec timewake;

CDateTimeH::AbsTimeFromNow(iMilliSeconds,&timewake);

iRet = pthread_rwlock_timedrdlock(&m_rwLock,&timewake);
if (iRet != 0)
{
return false;
}

return true;
}

/*
功能: 带超时的写锁
参数:
int iMilliSeconds[in] 超时时间单位ms
返回:
bool 成功
false 失败
*/
bool CRdWtLock::TimedWriteLock(int iMilliSeconds)
{
int iRet = -1;
struct timespec timewake;

CDateTimeH::AbsTimeFromNow(iMilliSeconds,&timewake);

iRet = pthread_rwlock_timedwrlock(&m_rwLock,&timewake);
if (iRet != 0)
{
return false;
}

return true;
}

/*
功能: 解锁
参数:
返回:
true 成功
false 失败
*/
bool CRdWtLock::UnLock()
{
int iRet = 0 ;

iRet = pthread_rwlock_unlock(&m_rwLock);
if(iRet != 0)
{
return false;
}

return true;
}

/*****************************普通读写锁*********************************/

/*****************************命名读写锁*********************************/
/*
功能: 构造含糊
参数:
返回:
*/
CNamedRdWtLock::CNamedRdWtLock(const char * pszLockName)
:m_strLockName(string(pszLockName)+string(".rwlock")),m_prwLock(NULL)
{

}

/*
功能: 析构函数
参数:
返回:
*/
CNamedRdWtLock::~CNamedRdWtLock()
{
//不能释放锁资源
}

/*
功能: 初始化锁
参数:
无
返回:
bool 成功
false 失败
*/
bool CNamedRdWtLock::Create()
{
CPosixShm Shm(m_strLockName.c_str());
pthread_rwlockattr_t rwLockAttr;

m_prwLock = (pthread_rwlock_t *)Shm.Alloc(sizeof(pthread_rwlock_t));
if (m_prwLock == NULL)
{
return false;
}
pthread_rwlockattr_init(&rwLockAttr);
pthread_rwlockattr_setpshared(&rwLockAttr,PTHREAD_PROCESS_SHARED);
pthread_rwlock_init(m_prwLock,&rwLockAttr);

return true;
}

/*
功能: 关联锁的共享内存
参数:
无
返回:
bool 成功
false 失败
*/
bool CNamedRdWtLock::Attach()
{
CPosixShm Shm(m_strLockName.c_str());

if (!Shm.Attach())
{
return false;
}
m_prwLock = (pthread_rwlock_t *)Shm.GetShmPoint();
if (m_prwLock == NULL)
{
return false;
}
return true;
}

/*
功能: 加读锁
参数:
无
返回:
bool 成功
false 失败
*/
bool CNamedRdWtLock::ReadLock()
{
int iRet = -1;

if (m_prwLock == NULL)
{
return false;
}
iRet = pthread_rwlock_rdlock(m_prwLock);
if (iRet != 0)
{
return false;
}

return true;
}

/*
功能: 加写锁
参数:
无
返回:
bool 成功
false 失败
*/
bool CNamedRdWtLock::WriteLock()
{
int iRet = -1;

if (m_prwLock == NULL)
{
return false;
}
iRet = pthread_rwlock_wrlock(m_prwLock);
if (iRet != 0)
{
return false;
}

return true;
}

/*
功能: 带超时的读锁
参数:
int iMilliSeconds[in] 超时时间单位ms
返回:
bool 成功
false 失败
*/
bool CNamedRdWtLock::TimedReadLock(int iMilliSeconds)
{
int iRet = -1;
struct timespec timewake;

if (m_prwLock == NULL)
{
return false;
}
CDateTimeH::AbsTimeFromNow(iMilliSeconds,&timewake);

iRet = pthread_rwlock_timedrdlock(m_prwLock,&timewake);
if (iRet != 0)
{
return false;
}

return true;
}

/*
功能: 带超时的写锁
参数:
int iMilliSeconds[in] 超时时间单位ms
返回:
bool 成功
false 失败
*/
bool CNamedRdWtLock::TimedWriteLock(int iMilliSeconds)
{
int iRet = -1;
struct timespec timewake;

if (m_prwLock == NULL)
{
return false;
}

CDateTimeH::AbsTimeFromNow(iMilliSeconds,&timewake);

iRet = pthread_rwlock_timedwrlock(m_prwLock,&timewake);
if (iRet != 0)
{
return false;
}

return true;
}

/*
功能: 解锁
参数:
返回:
true 成功
false 失败
*/
bool CNamedRdWtLock::UnLock()
{
int iRet = 0 ;

if (m_prwLock == NULL)
{
return false;
}
iRet = pthread_rwlock_unlock(m_prwLock);
if(iRet != 0)
{
return false;
}

return true;
}

/*
功能: 删除共享内存中的命名锁
参数:
无
返回:
bool 成功
false 失败
*/
bool CNamedRdWtLock::Remove()
{
CPosixShm Shm(m_strLockName.c_str());

if (!Shm.Attach())
{
return false;
}

return Shm.Remove();
}
/*****************************命名读写锁*********************************/

qingtianhit

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Posic lock API使用

都是早些年写的代码了，发上来做个纪念.../******************************************************************** * Copyright * All rights reserved * * 文件名称: posix_lock.h * 文件标示: * 摘要: 基于 posix 实现的锁
复制链接

扫一扫