synchronize.h

一个双向栈的C++实现

#ifndef SYNCHRONIZE_H_
#define SYNCHRONIZE_H_

#ifdef WIN32
#include <process.h>
#include <winbase.h>
#else
#include <stdlib.h>
#include <glib.h>
#include <glib/gatomic.h>
#include <glib/gthread.h>
#endif

class CAtomic
{   
public:
	static int AtomicExchangeAdd(volatile int* var, int val);
	static void AtomicAdd(volatile int* var, int value);
	static int AtomicCompareExchange(volatile int* var, int oldval, int newval);
	static int AtomicExchange(volatile int* var, int value);
private:
	CAtomic(void);
	~CAtomic(void);	
};

class CLock
{
private:

#ifdef WIN32
	CRITICAL_SECTION m_lock;
#else
	GMutex* m_lock;
#endif

public:
	void Lock(void);
	void UnLock(void);
	int TryLock(void);
public:
	CLock(void);
	~CLock(void);
};

#ifdef WIN32
inline int CAtomic::AtomicExchangeAdd(volatile int* var, int val)
{
	return InterlockedExchangeAdd((long*)var, val);
}

inline void CAtomic::AtomicAdd(volatile int* var, int val)
{
	InterlockedExchangeAdd((long*)var, val);
}

inline int CAtomic::AtomicCompareExchange(volatile int* var, int oldval, int newval)
{
	return InterlockedCompareExchange((long*)var, newval, oldval);
}

inline int CAtomic::AtomicExchange(volatile int* var, int value)
{
	return InterlockedExchange((long*)var, value);
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
inline CLock::CLock(void)
{
	InitializeCriticalSection(&m_lock);
}

inline CLock::~CLock(void)
{
	DeleteCriticalSection(&m_lock);
}

inline void CLock::Lock(void)
{
	EnterCriticalSection(&m_lock);
}

inline void CLock::UnLock(void)
{
	LeaveCriticalSection(&m_lock);
}

inline int CLock::TryLock(void)
{
	return TryEnterCriticalSection(&m_lock);
}

#else
inline int CAtomic::AtomicExchangeAdd(volatile int* var, int val)
{
	return g_atomic_int_exchange_and_add((gint*)var, val);
}

inline void CAtomic::AtomicAdd(volatile int* var, int val)
{
	g_atomic_int_add((gint*)var, val);
}

inline int CAtomic::AtomicCompareExchange(volatile int* var, int oldval, int newval)
{
	return g_atomic_int_compare_and_exchange((gint*)var, oldval, newval);
}

inline int CAtomic::AtomicExchange(volatile int* var, int value)
{
	return g_atomic_int_exchange((gint*)var, value);
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
inline CLock::CLock(void)
{
	if(!g_thread_supported())
	{
		g_thread_init(NULL);
	}
	m_lock = g_mutex_new();
}

inline CLock::~CLock(void)
{
	g_mutex_free(m_lock);
}

inline void CLock::Lock(void)
{
	g_mutex_lock(m_lock);
}

inline void CLock::UnLock(void)
{
	g_mutex_unlock(m_lock);
}

inline int CLock::TryLock(void)
{
	return g_mutex_trylock(m_lock);
}
#endif

#endif