在linux下实现类似WaitForSingleObjectEx功能

2023-03-16

利用pthread_cond_t在实现等待线程完成或超时，来达到类似WaitForSingleObjectEx的功能。

#include <pthread.h>
#include <sys/time.h>
#include <stdio.h>
#include <errno.h>
#include <unistd.h>

#define WAIT_TIMEOUT ETIMEDOUT
#define WAIT_OBJECT_0 0

void* ThreadFunc(void* args)
{
    // 等待 3 秒钟模拟子线程工作
    sleep(3);

    // 发送条件变量信号通知主线程完成
    pthread_cond_t* cond = (pthread_cond_t*)args;
    pthread_cond_signal(cond);

    return NULL;
}

// 使用条件变量模拟 WaitForSingleObjectEx
int WaitForSingleObjectEx(pthread_mutex_t* mutex, pthread_cond_t* cond, int timeout_ms) 
{
    struct timespec ts;
    clock_gettime(CLOCK_REALTIME, &ts);
    ts.tv_sec += timeout_ms / 1000;
    ts.tv_nsec += (timeout_ms % 1000) * 1000000;

    // 加锁并等待条件变量
    pthread_mutex_lock(mutex);
    int ret = pthread_cond_timedwait(cond, mutex, &ts);
    pthread_mutex_unlock(mutex);

    if (ret == ETIMEDOUT) {
        return WAIT_TIMEOUT;
    } else {
        return WAIT_OBJECT_0;
    }
}

// 在主线程中使用条件变量等待子线程完成
int main(int argc, char* argv[]) 
{
    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

    // 创建子线程
    pthread_t tid;
    pthread_create(&tid, NULL, ThreadFunc, &cond);

    // 等待子线程完成或超时
    int ret = WaitForSingleObjectEx(&mutex, &cond, 5000);
    if (ret == WAIT_OBJECT_0) {
        printf("Thread completed successfully.\n");
    } else {
        printf("Timeout waiting for thread.\n");
    }

    // 销毁条件变量和互斥锁
    pthread_cond_destroy(&cond);
    pthread_mutex_destroy(&mutex);

	return 0
}

另外一种实现方式

使用C++11中提供的std::condition_variable来实现等待和通知，使用std::mutex来保证线程安全，使用std::chrono来保证可以设置超时时间。
主要的思路是定义了一个Event类，通过该类中的Set、Reset和Wait函数来设置信号量、重置信号量和等待信号量。
CreateEvent函数返回的是Event类的实例指针，即同等于Windows中的事件句柄，
CloseHandle函数用于清除该指针所代表的资源，在本代码中即清除Event类的实例。
WaitForSingleObjectEx函数则是调用该事件实例所定义的Wait函数，实现等待信号量和设置超时时间的功能。

代码如下：

#include <chrono>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>

typedef unsigned long DWORD;
typedef void* HANDLE;

enum WAIT_RETURN {
    WAIT_OBJECT_0 = 0x00000000L,
    WAIT_ABANDONED = 0x00000080L,
    WAIT_TIMEOUT = 0x00000102L,
    WAIT_IO_COMPLETION = 0x000000C0L,
    WAIT_FAILED = 0xFFFFFFFFL
};

class Event {
   public:
    Event() : signaled_(false) {}

    void Set() {
        std::unique_lock<std::mutex> lock(mutex_);
        signaled_ = true;
        cv_.notify_all();
    }

    void Reset() {
        std::unique_lock<std::mutex> lock(mutex_);
        signaled_ = false;
    }

    DWORD Wait(DWORD timeout = INFINITE) {
        std::unique_lock<std::mutex> lock(mutex_);
        if (timeout == INFINITE) {
            cv_.wait(lock, [&] { return signaled_; });
            return WAIT_OBJECT_0;
        } else {
            auto result = cv_.wait_for(lock, std::chrono::milliseconds(timeout), [&] { return signaled_; });
            if (result == std::cv_status::timeout) {
                return WAIT_TIMEOUT;
            } else {
                return WAIT_OBJECT_0;
            }
        }
    }

   private:
    std::mutex mutex_;
    std::condition_variable cv_;
    bool signaled_;
};

HANDLE CreateEvent(void* lpEventAttributes, bool bManualReset, bool bInitialState,
                   char* lpName) {
    Event* event = new Event();
    if (bInitialState) {
        event->Set();
    }
    return static_cast<HANDLE>(event);
}

BOOL CloseHandle(HANDLE hObject) {
    Event* event = static_cast<Event*>(hObject);
    delete event;
    return true;
}

DWORD WaitForSingleObjectEx(HANDLE hHandle, DWORD dwMilliseconds, BOOL bAlertable) {
    Event* event = static_cast<Event*>(hHandle);
    return event->Wait(dwMilliseconds);
}