C++：Linux平台上的线程同步场景

我正在为 Linux 平台实现多线程 C++ 程序，其中我需要类似于 WaitForMultipleObjects() 的功能。

在搜索解决方案时，我发现有一些文章描述了如何在 Linux 中实现 WaitForMultipleObjects() 功能，并附有示例，但这些示例不满足我必须支持的场景。

我的情况非常简单。我有一个守护进程，其中主线程向外界公开方法/回调，例如向 DLL 公开。 DLL 的代码不在我的控制之下。同一个主线程创建一个新线程“Thread 1”。线程 1 必须执行一种无限循环，其中它将等待关闭事件（守护程序关闭），或者等待通过上述公开的方法/回调发出信号的数据可用事件。

简而言之，线程将等待关闭事件和数据可用事件，其中如果发出关闭事件信号，则等待将满足并且循环将被打破，或者如果发出数据可用事件信号，则等待也将满足并且线程将进行业务处理。

在 Windows 中，它看起来非常简单。下面是针对我的场景的基于 MS Windows 的伪代码。

//**Main thread**

//Load the DLL
LoadLibrary("some DLL")

//Create a new thread
hThread1 = __beginthreadex(..., &ThreadProc, ...)

//callback in main thread (mentioned in above description) which would be called by the     DLL
void Callbackfunc(data)
{
    qdata.push(data);
    SetEvent(s_hDataAvailableEvent);
}

void OnShutdown()
{
    SetEvent(g_hShutdownEvent);
    WaitforSingleObject(hThread1,..., INFINITE);
    //Cleanup here
}

//**Thread 1**

unsigned int WINAPI ThreadProc(void *pObject)
{
    while (true)
    {

        HANDLE hEvents[2];
        hEvents[0] = g_hShutdownEvent;
        hEvents[1] = s_hDataAvailableEvent;

        //3rd parameter is set to FALSE that means the wait should satisfy if state of  any one of the objects is signaled.
        dwEvent = WaitForMultipleObjects(2, hEvents, FALSE, INFINITE);
        switch (dwEvent) 
        {   
            case WAIT_OBJECT_0 + 0: 
            // Shutdown event is set, break the loop
            return 0;   

            case WAIT_OBJECT_0 + 1:
            //do business processing here
            break; 

            default: 
            // error handling
        }
    }
}

我想在 Linux 上实现同样的功能。根据我的理解，当涉及到Linux时，它有完全不同的机制，我们需要注册信号。如果终止信号到达，进程就会知道它即将关闭，但在此之前，进程必须等待正在运行的线程正常关闭。

在 Linux 中执行此操作的正确方法是使用条件变量。虽然这与WaitForMultipleObjects在 Windows 中，您将获得相同的功能。

Use two bool确定是否有可用数据或必须关闭。 然后让关闭函数和数据函数都相应地设置布尔值，并向条件变量发出信号。

#include <pthread.h>

pthread_cond_t cv = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

pthread_t hThread1; // this isn't a good name for it in linux, you'd be 
                    // better with something line "tid1" but for 
                    // comparison's sake, I've kept this

bool shutdown_signalled;
bool data_available;

void OnShutdown()
{
    //...shutdown behavior...
    pthread_mutex_lock(&mutex);
    shutdown_signalled = true;
    pthread_mutex_unlock(&mutex);
    pthread_cond_signal(&cv);
}

void Callbackfunc(...)
{
    // ... whatever needs to be done ...
    pthread_mutex_lock(&mutex);
    data_available = true;
    pthread_mutex_unlock(&mutex);
    pthread_cond_signal(&cv);
}


void *ThreadProc(void *args)
{
    while(true){
        pthread_mutex_lock(&mutex);
        while (!(shutdown_signalled || data_available)){
            // wait as long as there is no data available and a shutdown
            // has not beeen signalled
            pthread_cond_wait(&cv, &mutex);
        }
        if (data_available){
            //process data
            data_available = false;
        }
        if (shutdown_signalled){
            //do the shutdown
            pthread_mutex_unlock(&mutex);
            return NULL;
        }
        pthread_mutex_unlock(&mutex); //you might be able to put the unlock
        // before the ifs, idk the particulars of your code
    }
}
int main(void)
{
    shutdown_signalled = false;
    data_available = false;
    pthread_create(&hThread1, &ThreadProc, ...);
    pthread_join(hThread1, NULL);
    //...
}

我知道 Windows 也有条件变量，所以这看起来应该不会太陌生。我不知道 Windows 对它们有什么规则，但在 POSIX 平台上wait需要在 a 的内部while循环，因为可能会发生“虚假唤醒”。