跨平台互斥体封装

#ifndef __SR_MUTEX_H__
#define __SR_MUTEX_H__


#if (defined _WIN32 || defined _WIN64)
#define WIN32_LEAN_AND_MEAN  //解决winsock.h和winsock2.h类型重定义问题
	#include "windows.h"
	#include "process.h"
	#include "atlstr.h"
	#define SR_Mutex  CRITICAL_SECTION


/*************************** 线程锁定义 ************************************/

// 重新封装的互斥体类
class CSRMutex
{
public:
	// 构造函数
	CSRMutex();
	// 析构函数
	~CSRMutex();
	// 进入互斥锁
	void Lock();
	// 解锁
	void UnLock();
private:
	// win32下面是临界区 ，linux和apple下面是互斥锁
	SR_Mutex  m_pMutex;
};

#else
#include <pthread.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/file.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include "SharedMemory.h"
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#define SR_Mutex  pthread_mutex_t

 // 重新封装的互斥体类
class CSRMutex
{
public:
	// 构造函数
	CSRMutex();
	// 析构函数
	~CSRMutex();
	// 进入互斥锁
	void Lock();
	// 解锁
	void UnLock();
private:
	// win32下面是临界区 ，linux和apple下面是互斥体
	SR_Mutex  m_pMutex;
};


#endif//end windows

// 将互斥体的调用封装到一个锁中
class CSRLock
{
public:
	// win32 下面进入临界区 ， linux和apple下面进入互斥锁状态
	CSRLock(CSRMutex * pMutex)
	{
		m_pMutex = pMutex;
		if (NULL != pMutex)
		{
			pMutex->Lock();
		}
	};
#ifdef _WIN32
	// 进程锁构造
	CSRLock(CString chszLockName)
	{
		m_hProcMutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, chszLockName.GetString());//打开进程锁
		if (m_hProcMutex == NULL)
		{
			m_hProcMutex = CreateMutex(NULL, false, chszLockName.GetString());//创建进程锁
		}
		DWORD dw=WaitForSingleObject(m_hProcMutex, INFINITE);//获取进程锁
        if(dw != WAIT_OBJECT_0)
            printf("--------lock fail\r\n");
	};
#else
	CSRLock(char* chszLockName)
	{
		m_fp = fopen(chszLockName, "w+");
		if (m_fp == NULL )
		{
			printf("--------fp == NULL\r\n");
		}
		else
		{
			if (0 == flock(fileno(m_fp), LOCK_EX))
			{
				printf("--------lock success\r\n");
			}
			else
			{
				printf("--------lock fail\r\n");
			}
		}
	};
#endif

	// win32 下面出临界区 ， linux和apple下面出互斥锁
	~CSRLock()
	{
		if (NULL != m_pMutex)
		{
			m_pMutex->UnLock();
		}
		m_pMutex = NULL;

#ifdef _WIN32
		// 进程锁析构
		if (NULL != m_hProcMutex)
		{
			ReleaseMutex(m_hProcMutex);
			CloseHandle(m_hProcMutex);
		}
		m_hProcMutex = NULL;
#else
		{
			//unlock
			if (m_fp != NULL)
			{
				if (0 == flock(fileno(m_fp), LOCK_UN))
				{
					printf("--------unlock success\r\n");
				}
				else
				{
					printf("--------unlock fail\r\n");
				}

				fclose(m_fp);
			}
			
		}
#endif
	};
private:
	// 临界区/互斥锁相关的成员变量
	CSRMutex * m_pMutex = NULL;
#ifdef _WIN32
	HANDLE  m_hProcMutex = NULL;
#else

	FILE* m_fp = NULL;

#endif
};

#endif

#include "SRMutex.h"

/*************************** 线程锁定义 ************************************/
#if (defined _WIN32 || defined _WIN64)
/**	@fn	     CSRMutex
 *	@brief	 构造函数
 *	@return	
	见返回值类型说明
 */
CSRMutex::CSRMutex()
{
	

	InitializeCriticalSection(&m_pMutex);	

};

/**	@fn	     ~CSRMutex
 *	@brief	 析构函数
 *	@return	
	见返回值类型说明
 */
CSRMutex::~CSRMutex()
{
    DeleteCriticalSection(&m_pMutex);

};

/**	@fn	     Lock
 *	@brief	 进入锁状态
 *	@return	
	见返回值类型说明
 */
void CSRMutex::Lock()
{

    EnterCriticalSection(&m_pMutex);

};

/**	@fn	     UnLock
 *	@brief	 解锁
 *	@return	
	见返回值类型说明
 */
void CSRMutex::UnLock()
{

    LeaveCriticalSection(&m_pMutex);

};

#else

CSRMutex::CSRMutex()
{
	int ret = 0;
	pthread_mutexattr_t attr;
	pthread_mutexattr_init(&attr);

	pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP); //嵌套锁

	ret = pthread_mutex_init(&m_pMutex, &attr);

	pthread_mutexattr_destroy(&attr);//释放属性

	if (ret != 0)
	{
		m_pMutex = PTHREAD_MUTEX_INITIALIZER;
	}

};

/**	@fn	     ~CSRMutex
*	@brief	 析构函数
*	@return
见返回值类型说明
*/
CSRMutex::~CSRMutex()
{
	pthread_mutex_destroy(&m_pMutex);
};

/**	@fn	     Lock
*	@brief	 进入锁状态
*	@return
见返回值类型说明
*/
void CSRMutex::Lock()
{
	pthread_mutex_lock(&m_pMutex);
};

/**	@fn	     UnLock
*	@brief	 解锁
*	@return
见返回值类型说明
*/
void CSRMutex::UnLock()
{
	pthread_mutex_unlock(&m_pMutex);
};

#endif//end windows

当需要进程同步时，可构造进程锁(提供一个锁名称)，如果是线程同步，可构造线程锁(提供一个互斥体)。