10

我正在尝试在 Linux 中实现非常简单的 Windows 事件。仅适用于我的场景 - 3 个线程，1 个主线程和 2 个辅助线程。每个辅助线程通过 SetEvent 引发 1 个事件，主线程等待它。例子：

int main()
{
    void* Events[2];
    Events[0] = CreateEvent();
    Events[1] = CreateEvent();

    pthread_start(Thread, Events[0]);
    pthread_start(Thread, Events[1]);

    WaitForMultipleObjects(2, Events, 30000) // 30 seconds timeout

    return 0;
}

int* thread(void* Event)
{
    // Do something
    SetEvent(Event);
    // Do something
}

所以，为了实现它，我使用条件变量。但我的问题是 - 这是正确的方法吗？还是我做错了什么？我的实现：

// Actually, this function return pointer to struct with mutex and cond
// here i just simplified example
void* CreateEvent(mutex, condition)
{
    pthread_mutex_init(mutex, NULL);
    pthread_cond_init(condition, NULL);
}

bool SetEvent (mutex, condition)
{
    pthread_mutex_lock(mutex);
    pthread_cond_signal(condition);
    pthread_mutex_unlock(mutex);
}

int WaitForSingleObject(mutex, condition, timeout)
{
    pthread_mutex_lock(mutex);
    pthread_cond_timedwait(condition, mutex, timeout);
    pthread_mutex_unlock(mutex);
}

// Call WaitForSingleObject for each event. 
// Yes, i know, that its a wrong way, but it should work in my example.
int WaitForMultipleObjects(count, mutex[], condition[], timeout);

一切看起来都很好，但我认为，当我在主线程中调用 WaitFor.. 函数时，会出现这个问题，然后调用辅助线程中的 SetEvent。在 Windows 中，它运行良好，但在 Linux 中 - 上面仅描述了想法。

也许你告诉我更好的解决方法？谢谢你。

UPD：超时非常重要，因为其中一个辅助线程可能不会通过 SetEvent()。

4

3 回答 3

3

基于此描述WaitForSingleObject

WaitForSingleObject函数检查指定对象的当前状态。如果对象的状态是无信号的，则调用线程进入等待状态，直到对象发出信号或超时间隔过去。

该行为与代码之间的区别在于代码将始终等待条件变量，因为它不检查谓词。这引入了pthread_condt_timewaitandpthread_cond_signal调用之间的同步问题。

发出条件变量信号的一般习惯用法是：

锁定互斥锁
设置谓词
解锁互斥锁
信号条件变量

在等待条件变量时：

锁定互斥锁
而（！谓词）
{
  等待条件变量
}
解锁互斥锁

根据要完成的任务，bool可以使用单独的作为每个Event. 通过引入谓词，只应在未发出信号WaitForSingleObject时等待条件变量。Event代码将类似于以下内容：

bool SetEvent (mutex, condition)
{
    pthread_mutex_lock(mutex);                 // lock mutex
    bool& signalled = find_signal(condition);  // find predicate
    signalled = true;                          // set predicate
    pthread_mutex_unlock(mutex);               // unlock mutex
    pthread_cond_signal(condition);            // signal condition variable
}

int WaitForSingleObject(mutex, condition, timeout)
{
    pthread_mutex_lock(mutex);                         // lock mutex
    bool& signalled = find_signal(condition);          // find predicate
    while (!signalled)
    {
      pthread_cond_timedwait(condition, mutex, timeout);
    }
    signalled = false;                                 // reset predicate
    pthread_mutex_unlock(mutex);                       // unlock mutex
}
于 2012-10-23T13:27:29.960 回答
2

stackoverflow 上已经有类似的问题：WaitForSingleObject and WaitForMultipleObjects equivalent in linux

此外，您可以使用信号量：

sem_t semOne  ;
sem_t semTwo  ;
sem_t semMain ;

在主线程中：

sem_init(semOne,0,0) ;
sem_init(semTwo,0,0) ;
sem_init(semMain,0,0) ;

...


sem_wait(&semMain);

// Thread 1
sem_wait(&semOne);
sem_post(&semMain);


// Thread 2
sem_wait(&semTwo);
sem_post(&semMain);

详细描述和各种示例可以在这里找到：------ http://www.ibm.com/developerworks/linux/library/l-ipc2lin3/index.html

以前的链接不再可用。The Internet Archive's Wayback Machine 的最新存档版本是： https ://web.archive.org/web/20130515223326/http://www.ibm.com/developerworks/linux/library/l-ipc2lin3/index.html

于 2012-10-23T13:03:56.490 回答
0

我认为信号量在这里是一个更好的解决方案，因为它可以在进程间使用。可以封装接口，如果没有提供name，则使用pthread_初始化，供进程内使用，这样可以缩短资源使用量，但是使用name时，尽量使用sem初始化，供进程内使用。

于 2015-10-29T04:00:40.073 回答