跨平台实现Event事件（Linux+win）

1、第一种方法（win和linux通用）

//头文件.h
#ifndef _HIK_EVENT_H_   
#define _HIK_EVENT_H_  
  
#ifdef _MSC_VER  
#include <Windows.h>  
#define hik_event_handle HANDLE  
#else  
#include <pthread.h>  
typedef struct    
{  
    bool state;  
    bool manual_reset;  
    pthread_mutex_t mutex;  
    pthread_cond_t cond;  
}event_t;  
#define event_handle event_t*  
#endif  
  
//返回值：NULL 出错  
event_handle event_create(bool manual_reset, bool init_state);  
  
//返回值：0 等到事件，-1出错  
int event_wait(event_handle hevent);  
  
//返回值：0 等到事件，1 超时，-1出错  
int event_timedwait(event_handle hevent, long milliseconds);  
  
//返回值：0 成功，-1出错  
int event_set(event_handle hevent);  
  
//返回值：0 成功，-1出错  
int event_reset(event_handle hevent);  
  
//返回值：无  
void event_destroy(event_handle hevent);  
  
#endif  
  
/// 
//源文件.cpp：
#include "event.h"  
#ifdef __linux  
#include <sys/time.h>  
#include <errno.h>  
#endif  
#include <iostream>  
event_handle event_create(bool manual_reset, bool init_state)  
{     
#ifdef _MSC_VER  
    HANDLE hevent = CreateEvent(NULL, manual_reset, init_state, NULL);  
#else  
    event_handle hevent = new(std::nothrow) event_t;  
    if (hevent == NULL)  
    {  
        return NULL;  
    }  
    hevent->state = init_state;  
    hevent->manual_reset = manual_reset;  
    if (pthread_mutex_init(&hevent->mutex, NULL))  
    {  
        delete hevent;  
        return NULL;  
    }  
    if (pthread_cond_init(&hevent->cond, NULL))  
    {  
        pthread_mutex_destroy(&hevent->mutex);  
        delete hevent;  
        return NULL;  
    }  
#endif  
    return hevent;  
}  
int event_wait(event_handle hevent)  
{  
#ifdef _MSC_VER  
    DWORD ret = WaitForSingleObject(hevent, INFINITE);  
    if (ret == WAIT_OBJECT_0)  
    {  
        return 0;  
    }  
    return -1;  
#else  
    if (pthread_mutex_lock(&hevent->mutex))     
    {        
        return -1;     
    }     
    while (!hevent->state)      
    {        
        if (pthread_cond_wait(&hevent->cond, &hevent->mutex))     
        {     
            pthread_mutex_unlock(&hevent->mutex);   
            return -1;     
        }     
    }     
    if (!hevent->manual_reset)   
    {  
        hevent->state = false;  
    }  
    if (pthread_mutex_unlock(&hevent->mutex))     
    {       
        return -1;     
    }    
    return 0;  
#endif  
}  
int event_timedwait(event_handle hevent, long milliseconds)  
{  
#ifdef _MSC_VER  
    DWORD ret = WaitForSingleObject(hevent, milliseconds);  
    if (ret == WAIT_OBJECT_0)  
    {  
        return 0;  
    }  
    if (ret == WAIT_TIMEOUT)  
    {  
        return 1;  
    }  
    return -1;  
#else  
  
    int rc = 0;     
    struct timespec abstime;     
    struct timeval tv;     
    gettimeofday(&tv, NULL);     
    abstime.tv_sec  = tv.tv_sec + milliseconds / 1000;     
    abstime.tv_nsec = tv.tv_usec*1000 + (milliseconds % 1000)*1000000;     
    if (abstime.tv_nsec >= 1000000000)     
    {     
        abstime.tv_nsec -= 1000000000;     
        abstime.tv_sec++;     
    }     
  
    if (pthread_mutex_lock(&hevent->mutex) != 0)     
    {       
        return -1;     
    }     
    while (!hevent->state)      
    {        
        if (rc = pthread_cond_timedwait(&hevent->cond, &hevent->mutex, &abstime))     
        {     
            if (rc == ETIMEDOUT) break;     
            pthread_mutex_unlock(&hevent->mutex);      
            return -1;     
        }     
    }     
    if (rc == 0 && !hevent->manual_reset)     
    {  
        hevent->state = false;  
    }  
    if (pthread_mutex_unlock(&hevent->mutex) != 0)     
    {        
        return -1;     
    }  
    if (rc == ETIMEDOUT)  
    {  
        //timeout return 1  
        return 1;  
    }  
    //wait event success return 0  
    return 0;  
#endif  
}  
int event_set(event_handle hevent)  
{  
#ifdef _MSC_VER  
    return !SetEvent(hevent);  
#else  
    if (pthread_mutex_lock(&hevent->mutex) != 0)  
    {  
        return -1;  
    }  
  
    hevent->state = true;  
  
    if (hevent->manual_reset)  
    {  
        if(pthread_cond_broadcast(&hevent->cond))  
        {  
            return -1;  
        }  
    }  
    else  
    {  
        if(pthread_cond_signal(&hevent->cond))  
        {  
            return -1;  
        }  
    }  
  
    if (pthread_mutex_unlock(&hevent->mutex) != 0)  
    {  
        return -1;  
    }  
  
    return 0;  
#endif  
}  
int event_reset(event_handle hevent)   
{  
#ifdef _MSC_VER  
    //ResetEvent 返回非零表示成功  
    if (ResetEvent(hevent))  
    {  
        return 0;  
    }   
    return -1;  
#else  
    if (pthread_mutex_lock(&hevent->mutex) != 0)  
    {  
        return -1;  
    }  
  
    hevent->state = false;  
  
    if (pthread_mutex_unlock(&hevent->mutex) != 0)  
    {        
        return -1;  
    }  
    return 0;  
#endif  
}  
void event_destroy(event_handle hevent)  
{  
#ifdef _MSC_VER  
    CloseHandle(hevent);  
#else  
    pthread_cond_destroy(&hevent->cond);  
    pthread_mutex_destroy(&hevent->mutex);  
    delete hevent;  
#endif  
}
2、第二种方法（linux下实现win的event）

(1)头文件

首先是event.h文件，实现event类

#include <pthread.h>
#include <sys/time.h>
 
const int INFINITE = -1;
class CEvent
{
public:
    CEvent(bool bIsManualReset, bool bInitialSignaled);
    ~CEvent();
    bool CreateEvent();
    bool Set();
    bool Reset();
    bool Wait(int cms);
private:
    bool EnsureInitialized();
    bool m_bIsManualReset;
    bool m_bEventStatus;
    bool m_bMutexInitialized;
    pthread_mutex_t m_mutex;
    bool m_bCondInitialized;
    pthread_cond_t m_cond;
};
 
CEvent::CEvent(bool bIsManualReset, bool bInitialSignaled)
: m_bIsManualReset(bIsManualReset)
, m_bEventStatus(bInitialSignaled)
, m_bMutexInitialized(false)
, m_bCondInitialized(false)
{
    
}
 
CEvent::~CEvent()
{
    if (m_bMutexInitialized)
    {
        pthread_mutex_destroy(&m_mutex);
        m_bMutexInitialized = false; 
    }
 
    if (m_bCondInitialized)
    {
        pthread_cond_destroy(&m_cond);
        m_bCondInitialized = false;   
    }
}
 
 
bool CEvent::CreateEvent()
{
    if (!m_bMutexInitialized)
    {
        if (0 == pthread_mutex_init(&m_mutex, NULL))
        {
            m_bMutexInitialized = true; 
        }
    }
 
    if (!m_bCondInitialized)
    {
        if (0 == pthread_cond_init(&m_cond, NULL))
        {
            m_bCondInitialized = true;   
        }
    }
 
    return ( m_bMutexInitialized && m_bCondInitialized); 
}
 
bool CEvent::EnsureInitialized()
{
    return ( m_bMutexInitialized && m_bCondInitialized); 
}
 
bool CEvent::Set()
{
    if (!EnsureInitialized())
    {
        return false;
    }    
 
    pthread_mutex_lock(&m_mutex);
    m_bEventStatus = true;
    pthread_cond_broadcast(&m_cond);
    pthread_mutex_unlock(&m_mutex);
    return true;    
}
 
bool CEvent::Reset()
{
    if (!EnsureInitialized())
    {
        return false;
    }
 
    pthread_mutex_lock(&m_mutex);
    m_bEventStatus = false;
    pthread_mutex_unlock(&m_mutex);
    return true;    
}
 
bool CEvent::Wait(int cms)
{
    if (!EnsureInitialized())
    {
        return false;
    }
 
    pthread_mutex_lock(&m_mutex);
    int error = 0;
 
    if (cms != INFINITE)
    {
        struct timeval tv;
        gettimeofday(&tv, NULL);
 
        struct timespec ts;
        ts.tv_sec = tv.tv_sec + (cms / 1000);
        ts.tv_nsec = tv.tv_usec * 1000 + (cms % 1000) * 1000000; 
 
        if (ts.tv_nsec >= 1000000000)
        {
            ts.tv_sec++;
            ts.tv_nsec -= 1000000000;
        }
 
        while ((!m_bEventStatus) && (error == 0))
        {
            error = pthread_cond_timedwait(&m_cond, &m_mutex, &ts);
        }
    }
    else
    {
        while ((!m_bEventStatus) && (error == 0))
        {
            error = pthread_cond_wait(&m_cond, &m_mutex);
        }
    }
 
    if (0 == error && !m_bIsManualReset)
    {
        m_bEventStatus = false;
    } 
 
    pthread_mutex_unlock(&m_mutex);
 
    return (0 == error);
}
 
（2）接下来是调用event类的文件main.cpp：

#include <unistd.h>
#include <assert.h>
#include <stdio.h>
#include "event.h"
CEvent *g_event = NULL;
 
CEvent *CreateEvent(bool bManualReset, bool bInitialState)
{
    CEvent *pEvent = new CEvent(bManualReset, bInitialState);
    assert(pEvent);
 
    bool bRet = pEvent->CreateEvent();
    assert(bRet);
 
    return pEvent;
}
 
unsigned int WaitForSingleObject(CEvent *pEvent, int cms)
{
    assert(pEvent);
    if( pEvent->Wait(cms) )
    {
        return 0;
    }
 
    return 1;
}
 
bool CloseHandle(CEvent *pEvent)
{
    delete pEvent;
}
 
bool SetEvent(CEvent *pEvent)
{
    pEvent->Set();
}
 
bool ResetEvent(CEvent *pEvent)
{
    pEvent->Reset();
}
 
void *pFunc1(void *pEvent)
{
    while (1)
    {
        WaitForSingleObject(g_event, INFINITE);
        printf("this is func1 print!\n");
        sleep(1);
        ResetEvent(g_event); 
    }
}
 
void *pFunc2(void *pEvent)
{
    while (1)
    {
        sleep(5);
        printf("this is func2 print!\n");
        SetEvent(g_event);
    }
}
 
int main()
{
    
    //g_event = CreateEvent(false, true);
    g_event = CreateEvent(true, true);
 
    pthread_t pid1;
    pthread_t pid2;
 
    pthread_create(&pid1, NULL, pFunc1, NULL); 
    pthread_create(&pid2, NULL, pFunc2, NULL); 
    
    pthread_join(pid1, NULL); 
    pthread_join(pid2, NULL);
    
    CloseHandle(g_event);
    return 0;  
}
在main.cpp文件中对事件类进行的使用函数进行封装，然后在两个线程中可以采用类似于windows中使用事件的形式来使用。上面的event事件同windows下一样，支持手动和自动。