fx_process.h

浏览该文件的文档.

#ifndef _FX_PROCESS_H_
#define _FX_PROCESS_H_

#ifndef _FX_BASIC_H_
  #include "fx_basic.h"
#endif

#if _FX_OS_ == _FX_LINUX_DESKTOP_ || _FX_OS_ == _FX_LINUX_EMBEDDED_ || _FX_OS_ == _FX_ANDROID_ || _FX_OS_ == _FX_MACOSX_ || _FX_OS_ == _FX_IOS_
  #include <time.h>
  #include <sys/time.h>
  #include <pthread.h>
  #include <unistd.h>
#endif

//外部类
class CFX_ProcessContext;
class CFX_ThreadContext;
class CFX_ExceptionContext;

//*****************************************************************************
//* 时间
//*****************************************************************************
#ifdef __cplusplus
extern "C" {
#endif


typedef struct _FX_SYSTEMTIME
{
  FX_WORD wYear;      //年
  FX_WORD wMonth;      //月，1 - 12
  FX_WORD wDayOfWeek;    //星期几，星期日为0，星期一为1，...
  FX_WORD wDay;      //月中的日，从1开始 - 31
  FX_WORD wHour;      //小时，0 - 23
  FX_WORD wMinute;    //分钟，0 - 59
  FX_WORD wSecond;    //秒，0 - 59
  FX_WORD wMilliseconds;  //毫秒，0 - 999
} FX_SYSTEMTIME;

void    FX_Time_GetSystemTime(FX_SYSTEMTIME* pSystemTime);void    FX_Time_GetLocalTime(FX_SYSTEMTIME* pSystemTime);
FX_DWORD  FX_Time_GetClock();
FX_DWORD  FX_Time_Sleep(FX_DWORD dwMilliseconds);

typedef struct _FXCRT_DATETIMEZONE
{
  FX_WORD    year;
  FX_WORD    month;
  FX_WORD    day;
  FX_WORD    dayOfWeek;
  FX_WORD    hour;
  FX_WORD    minute;
  FX_WORD    second;
  FX_WORD    milliseconds;
  FX_INT32  tzHour;//TESTDOC: BUG#CORE-2923
  FX_WORD    tzMinute;
} FXCRT_DATETIMEZONE;

void    FXCRT_GetCurrentSystemTime(FXCRT_DATETIMEZONE& dt);

#ifdef __cplusplus
}
#endif

//*****************************************************************************
//* 进程
//*****************************************************************************
#ifdef __cplusplus
extern "C" {
#endif


#if _FX_OS_ == _FX_LINUX_DESKTOP_ || _FX_OS_ == _FX_MACOSX_ || _FX_OS_ == _FX_IOS_

  typedef  pid_t    FX_PROCESSID;
#else

  typedef FX_DWORD  FX_PROCESSID;
#endif


void        FX_Process_Initialize();
void        FX_Process_Finalize();
FX_PROCESSID    FX_Process_GetID();

FX_LPVOID      FX_Process_GetPrivateData(FX_LPVOID key);
void        FX_Process_SetPrivateData(FX_LPVOID key, FX_LPVOID data, PD_CALLBACK_FREEDATA callback);
void        FX_Process_RemovePrivateData(FX_LPVOID key);

CFX_ProcessContext*  FX_Process_GetContext();

#ifdef __cplusplus
}
#endif

//*****************************************************************************
//* 线程
//*****************************************************************************
#ifdef __cplusplus
extern "C" {
#endif


FX_DEFINEHANDLE(FX_HTHREAD);

/*
#if _FX_OS_ == _FX_LINUX_DESKTOP_ || _FX_OS_ == _FX_MACOSX_ || _FX_OS_ == _FX_IOS_
  typedef pthread_t  FX_THREADID;
#else
  typedef FX_DWORD  FX_THREADID;
#endif
*/


#define FX_THREADPRIORITY_Lowest  -2

#define FX_THREADPRIORITY_Lower    -1

#define FX_THREADPRIORITY_Normal  0

#define FX_THREADPRIORITY_Higher  1

#define FX_THREADPRIORITY_Highest  2


#if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
typedef DWORD FX_ThreadResult;
#   define THREAD_CALL_CONVENTION WINAPI
#else
typedef FX_LPVOID FX_ThreadResult;
#   define THREAD_CALL_CONVENTION
#endif

typedef FX_ThreadResult (THREAD_CALL_CONVENTION *FX_CALLBACK_ThreadProc)(FX_LPVOID param);

typedef FX_ThreadResult (THREAD_CALL_CONVENTION *FX_CALLBACK_ThreadProxyProc)(FX_CALLBACK_ThreadProc threadProc, FX_LPVOID param);


typedef struct _FX_THREADHANDLER
{
  FX_LPVOID    pUserData;

  FX_HTHREAD    (*CreateThread)(FX_LPVOID pUserData, FX_INT32 nPriority, size_t szStack, FX_CALLBACK_ThreadProc lpfThreadProc, FX_LPVOID param);
  FX_BOOL      (*ExitThread)(FX_LPVOID pUserData);
  FX_HTHREAD    (*GetCurrentThread)(FX_LPVOID pUserData);
  void      (*Yield)(FX_LPVOID pUserData);
  FX_INT32    (*GetThreadPriority)(FX_LPVOID pUserData, FX_HTHREAD hThread);
  void      (*SetThreadPriority)(FX_LPVOID pUserData, FX_HTHREAD hThread, FX_INT32 nPriority);
  FX_INT32    (*WaitForSingleThread)(FX_LPVOID pUserData, FX_HTHREAD hThread);
  FX_INT32    (*WaitForMultipleThreads)(FX_LPVOID pUserData, const FX_HTHREAD* pThreads, FX_INT32 nCount);
}FX_THREADHANDLER;

FX_THREADHANDLER*    FX_Thread_GetHandler();
void          FX_Thread_SetHandler(FX_THREADHANDLER* pThreadHandler);


FX_HTHREAD        FX_Thread_Create(FX_INT32 nPriority, size_t szStack, FX_CALLBACK_ThreadProc threadProc, FX_LPVOID param);

void          FX_Thread_Exit();

FX_HTHREAD        FX_Thread_GetHandle();

void          FX_Thread_Yield();

FX_INT32        FX_Thread_GetLastError();
void          FX_Thread_SetLastError(FX_INT32 nErr);

FX_LPVOID        FX_Thread_GetPrivateData(FX_LPVOID key);
void          FX_Thread_SetPrivateData(FX_LPVOID key, FX_LPVOID data, PD_CALLBACK_FREEDATA callback);
void          FX_Thread_RemovePrivateData(FX_LPVOID key);

FX_INT32        FX_Thread_GetPriority(FX_HTHREAD hThread);
void          FX_Thread_SetPriority(FX_HTHREAD hThread, FX_INT32 nPriority);

FX_INT32        FX_Thread_WaitForSingleThread(FX_HTHREAD hThread);
FX_INT32        FX_Thread_WaitForMultipleThreads(const FX_HTHREAD* pThreads, FX_INT32 nCount);


CFX_ThreadContext*    FX_Thread_GetContext();

CFX_ExceptionContext*  FX_Thread_GetExceptionContext();

#ifdef __cplusplus
}
#endif

//*****************************************************************************
//* 并发控制
//*****************************************************************************

#ifdef __cplusplus
extern "C" {
#endif

FX_BOOL      FX_Mutex_Initialize(FX_MUTEX* pMutex);
void      FX_Mutex_Destroy(FX_MUTEX* pMutex);
FX_BOOL      FX_Mutex_TryLock(FX_MUTEX* pMutex);
void      FX_Mutex_Lock(FX_MUTEX* pMutex);
void      FX_Mutex_Unlock(FX_MUTEX* pMutex);

#ifdef __cplusplus
}
#endif


#ifdef __cplusplus
extern "C" {
#endif

FX_BOOL      FX_SpinLock_Initialize(FX_SPINLOCK* pSpinLock);
void      FX_SpinLock_Destroy(FX_SPINLOCK* pSpinLock);
FX_BOOL      FX_SpinLock_TryLock(FX_SPINLOCK* pSpinLock);
void      FX_SpinLock_Lock(FX_SPINLOCK* pSpinLock);
void      FX_SpinLock_Unlock(FX_SPINLOCK* pSpinLock);
FX_BOOL      FX_SpinLock_IsLocked(FX_SPINLOCK* pSpinLock);

#ifdef __cplusplus
}
#endif

#ifdef _FPDFAPI_MT_

class CFX_SpinLock
{
 public:
  CFX_SpinLock() : m_pSpinLock(NULL) {}
  CFX_SpinLock(FX_SPINLOCK* pSpinLock) : m_pSpinLock(pSpinLock) {if (m_pSpinLock) FX_SpinLock_Lock(m_pSpinLock);}
  ~CFX_SpinLock() {if (m_pSpinLock) FX_SpinLock_Unlock(m_pSpinLock);}

  FX_BOOL    TryLock() {return FX_SpinLock_TryLock(m_pSpinLock);}
  void    Lock() {FX_SpinLock_Lock(m_pSpinLock);}
  void    Unlock() {FX_SpinLock_Unlock(m_pSpinLock);}
  FX_BOOL    IsLocked() {return FX_SpinLock_IsLocked(m_pSpinLock);}

  FX_SPINLOCK*  m_pSpinLock;
};

#define FXMT_SPLOCK_THIS CFX_SpinLock _fx_splock((FX_SPINLOCK*)this)

#define FXMT_SPLOCK_OBJ(lock) CFX_SpinLock _fx_splock(lock)

#else

class CFX_SpinLock {};
#define FXMT_SPLOCK_THIS
#define FXMT_SPLOCK_OBJ(lock)

#endif


#ifdef __cplusplus
extern "C" {
#endif

FX_BOOL      FX_RWLock_Initialize(FX_RWLOCK* pRWLock);
void      FX_RWLock_Destroy(FX_RWLOCK* pRWLock);
FX_BOOL      FX_RWLock_TryReadLock(FX_RWLOCK* pRWLock);
void      FX_RWLock_ReadLock(FX_RWLOCK* pRWLock);
void      FX_RWLock_ReadUnlock(FX_RWLOCK* pRWLock);
FX_BOOL      FX_RWLock_TryWriteLock(FX_RWLOCK* pRWLock);
void      FX_RWLock_WriteLock(FX_RWLOCK* pRWLock);
void      FX_RWLock_WriteUnlock(FX_RWLOCK* pRWLock);

#ifdef __cplusplus
}
#endif

#ifdef _FPDFAPI_MT_

class CFX_RWLockObject : public CFX_Object
{
 public:
  CFX_RWLockObject() {FX_RWLock_Initialize(&m_Lock);}
  ~CFX_RWLockObject() {FX_RWLock_Destroy(&m_Lock);}

  FX_BOOL    TryReadLock()  {return FX_RWLock_TryReadLock(&m_Lock);}
  void    ReadLock()    {FX_RWLock_ReadLock(&m_Lock);}
  void    ReadUnlock()  {FX_RWLock_ReadUnlock(&m_Lock);}
  FX_BOOL    TryWriteLock()  {return FX_RWLock_TryWriteLock(&m_Lock);}
  void    WriteLock()    {FX_RWLock_WriteLock(&m_Lock);}
  void    WriteUnlock()  {FX_RWLock_WriteUnlock(&m_Lock);}

 protected:
  /* 临界区。 */
  FX_RWLOCK  m_Lock;
  friend class CFX_RWLock;
};

class CFX_RWLock
{
 public:
  CFX_RWLock() : m_pRWLock(NULL), m_nStatus(0) {}
  CFX_RWLock(FX_RWLOCK* pRWLock, FX_INT32 nStatus) : m_pRWLock(NULL), m_nStatus(0)
  {
    Init(pRWLock, nStatus);
  }
  CFX_RWLock(CFX_RWLockObject* pRWLockObj, FX_INT32 nStatus) : m_pRWLock(NULL), m_nStatus(0)
  {
    Init(&pRWLockObj->m_Lock, nStatus);
  }
  ~CFX_RWLock()
  {
    if (!m_pRWLock || !m_nStatus) return;
    if (m_nStatus < 0)
      FX_RWLock_ReadUnlock(m_pRWLock);
    else
      FX_RWLock_WriteUnlock(m_pRWLock);
  }

  FX_BOOL    TryReadLock()
  {
    if (FX_RWLock_TryReadLock(m_pRWLock))
    {
      m_nStatus = -1;
      return true;
    }
    return false;
  }
  void    ReadLock()
  {
    FX_RWLock_ReadLock(m_pRWLock);
    m_nStatus = -1;
  }
  void    ReadUnlock()
  {
    m_nStatus = 0;
    FX_RWLock_ReadUnlock(m_pRWLock);
  }
  FX_BOOL    TryWriteLock()
  {
    if (FX_RWLock_TryWriteLock(m_pRWLock))
    {
      m_nStatus = 1;
      return true;
    }
    return false;
  }
  void    WriteLock()
  {
    FX_RWLock_WriteLock(m_pRWLock);
    m_nStatus = 1;
  }
  void    WriteUnlock()
  {
    m_nStatus = 0;
    FX_RWLock_WriteUnlock(m_pRWLock);
  }

 protected:
  FX_RWLOCK*  m_pRWLock;
  FX_INT32  m_nStatus;

  void  Init(FX_RWLOCK* pRWLock, FX_INT32 nStatus)
  {
    m_pRWLock = pRWLock, m_nStatus = nStatus;
    if (!m_pRWLock || !m_nStatus) return;
    if (m_nStatus < 0)
      FX_RWLock_ReadLock(m_pRWLock);
    else
      FX_RWLock_WriteLock(m_pRWLock);
  }
};

#define FXMT_RWLOCK_THIS            CFX_RWLock _fx_rwlock((CFX_RWLock*)this)

#define FXMT_RWLOCK_OBJ(lock, s)        CFX_RWLock _fx_rwlock(lock, s)

#define FXMT_RWLOCK_DEFINEOBJ(rwLock, lock, s)  CFX_RWLock rwLock(lock, s)

#define FXMT_RWLOCKOBJECT_DEFINE(rwLockObj)    CFX_RWLockObject rwLockObj

#define FXMT_RWLOCKOBJECT_TRYREADLOCK(lockObj)  (lockObj)->TryReadLock()

#define FXMT_RWLOCKOBJECT_TRYREADLOCK_IF(lockObj)  if ((lockObj)->TryReadLock())

#define FXMT_RWLOCKOBJECT_READLOCK(lockObj)    (lockObj)->ReadLock()

#define FXMT_RWLOCKOBJECT_READUNLOCK(lockObj)    (lockObj)->ReadUnlock()

#define FXMT_RWLOCKOBJECT_TRYWRITELOCK(lockObj)  (lockObj)->TryWriteLock()

#define FXMT_RWLOCKOBJECT_TRYWRITELOCK_IF(lockObj)  if ((lockObj)->TryWriteLock())

#define FXMT_RWLOCKOBJECT_WRITELOCK(lockObj)    (lockObj)->WriteLock()

#define FXMT_RWLOCKOBJECT_WRITEUNLOCK(lockObj)    (lockObj)->WriteUnlock()
#else

class CFX_RWLock {};
#define FXMT_RWLOCK_THIS
#define FXMT_RWLOCK_OBJ(lock, s)
#define FXMT_RWLOCK_DEFINEOBJ(rwLock, lock, s)

#define FXMT_RWLOCKOBJECT_DEFINE(rwLockObj)
#define FXMT_RWLOCKOBJECT_TRYREADLOCK(lockObj)
#define FXMT_RWLOCKOBJECT_TRYREADLOCK_IF(lockObj)
#define FXMT_RWLOCKOBJECT_READLOCK(lockObj)
#define FXMT_RWLOCKOBJECT_READUNLOCK(lockObj)
#define FXMT_RWLOCKOBJECT_TRYWRITELOCK(lockObj)
#define FXMT_RWLOCKOBJECT_TRYWRITELOCK_IF(lockObj)
#define FXMT_RWLOCKOBJECT_WRITELOCK(lockObj)
#define FXMT_RWLOCKOBJECT_WRITEUNLOCK(lockObj)
#endif

//*****************************************************************************
//* 原子计数
//*****************************************************************************

#ifdef __cplusplus
extern "C" {
#endif

FX_INT32  FX_Atom_Add32(volatile FX_INT32* pAddend, FX_INT32 nIncrement);
FX_INT32  FX_Atom_Subtract32(volatile FX_INT32* pAddend, FX_INT32 nDecrement);
FX_INT64  FX_Atom_Add64(volatile FX_INT64* pAddend, FX_INT64 nIncrement);
FX_INT64  FX_Atom_Subtract64(volatile FX_INT64* pAddend, FX_INT64 nDecrement);

#ifdef __cplusplus
}
#endif

#endif  /* _FX_PROCESS_H_ */