如何在VxWorks中避免条件变量中的争用条件

从描述中可以看出，您可能想要实现（或使用）信号量 - 它是一种标准的 CS 算法，其语义类似于 condvars，并且有大量关于如何实现它们的教科书（https://www.google.com/search?q=semaphore+algorithm）。

解释信号量的随机谷歌结果位于：http://www.cs.cornell.edu/courses/cs414/2007sp/lectures/08-bakery.ppt（见幻灯片 32）。

使用本机 vxworks 应该很容易，这里需要消息队列。您的wait_for方法可以按原样使用。

bool condition::wait_for(mutex& mutex) const 
{
    unlocker ul(mutex);    // relinquish mutex
    return wait(event);
}                          // ul's dtor grabs mutex again

但是 wait（event） 代码如下所示：

wait(event)
{
    if (msgQRecv(event->q, sigMsgBuf, sigMsgSize, timeoutTime) == OK)
    {
        // got it...
    }
    else
    {
        // timeout, report error or something like that....
    }
}

你的信号代码是这样的：

signal(event)
{
    msgQSend(event->q, sigMsg, sigMsgSize, NO_WAIT, MSG_PRI_NORMAL);
}

因此，如果信号在您开始等待之前被触发，那么 msgQRecv 将在最终调用信号时立即返回信号，然后您可以如上所述在 ul dtor 中再次使用互斥锁。

event->q 是在事件创建时通过调用 msgQCreate 创建的MSG_Q_ID，sigMsg 中的数据由您定义......但可以只是一个随机的数据字节，或者你可以想出一个更智能的结构，其中包含有关谁发出信号的信息或其他可能很高兴知道的东西。

更新多个服务员，这有点棘手： 因此，我将做出一些假设来简化事情

1. 待处理的任务数在事件创建时是已知的，并且是恒定的。
2. 将有一个任务始终负责指示何时可以解锁互斥锁，所有其他任务只需要在事件发出信号/完成时发出通知。

这种方法使用计数信号量，类似于上面的信号量，只是稍微增加了一点逻辑：

wait(event)
{
    if (semTake(event->csm, timeoutTime) == OK)
    {
        // got it...
    }
    else
    {
        // timeout, report error or something like that....
    }
}

你的信号代码是这样的：

signal(event)
{
    for (int x = 0; x < event->numberOfWaiters; x++)
    {
        semGive(event->csm);
    }
}

事件的创建是这样的，请记住，在此示例中，服务员的数量是恒定的，并且在事件创建时是已知的。您可以将其设置为动态的，但关键是每次事件发生时，在解锁器解锁互斥锁之前，numberOfWaiters 必须正确。

createEvent(numberOfWaiters)
{
    event->numberOfWaiters = numberOfWaiters;
    event->csv = semCCreate(SEM_Q_FIFO, 0);
    return event;
}

你不能对 numberOfWaiters :D一厢情愿我再说一遍：在解锁器解锁互斥锁之前，numberOfWaiters 必须正确。要使其动态化（如果这是必需的），您可以添加一个 setNumWaiters（numOfWaiters） 函数，并在解锁器解锁互斥锁之前在 wait_for 函数中调用该函数，只要它始终正确设置数字即可。

现在对于最后一个技巧，如上所述，假设一个任务负责解锁互斥锁，其余任务只是等待信号，这意味着只有一个任务将调用上面的 wait_for（） 函数，其余任务只需调用 wait（event） 函数。

考虑到这一点，numberOfWaiters 的计算方式如下：

• 将调用 wait（） 的任务数
• 加 1 表示调用 wait_for（） 的任务

当然，如果你真的需要，你也可以让它更复杂，但这很可能会起作用，因为通常 1 个任务会触发一个事件，但许多任务想知道它是否完成，这就是它所提供的。

但您的基本流程如下：

init()
{
    event->createEvent(3);
}

eventHandler()
{
    locker l(mutex);
    doEventProcessing();
    signal(event);
}

taskA()
{
    doOperationThatTriggersAnEvent();
    wait_for(mutex);
    eventComplete();
}

taskB()
{
    doWhateverIWant();
    // now I need to know if the event has occurred...
    wait(event);
    coolNowIKnowThatIsDone();
}

taskC()
{
    taskCIsFun();
    wait(event);
    printf("event done!\n");
}

当我写上面的内容时，我觉得所有的 OO 概念都死了，但希望你能明白，实际上等待，wait_for应该采用相同的参数，或者没有参数，而是成为同一类的成员，该类也拥有他们需要知道的所有数据......但最重要的是它如何工作的概述。

如果每个等待任务都在单独的二进制信号量上等待，则可以避免争用条件。 这些信号量必须注册到一个容器中，信令任务使用该容器来取消阻止所有等待任务。容器必须受互斥锁保护。

该方法获取二进制信号量，等待它，最后删除它。wait_for()

void condition::wait_for(mutex& mutex) {
    SEM_ID sem = semBCreate(SEM_Q_PRIORITY, SEM_EMPTY);
    {
        lock l(listeners_mutex);    // assure exclusive access to listeners container
        listeners.push_back(sem);       
    }                               // l's dtor unlocks listeners_mutex again

    unlocker ul(mutex);             // relinquish mutex
    semTake(sem, WAIT_FOREVER);

    {
        lock l(listeners_mutex);
        // remove sem from listeners
        // ...
        semDelete(sem);
    }
}                                   // ul's dtor grabs mutex again

该方法遍历所有已注册的信号量并解锁它们。signal()

void condition::signal() {
    lock l(listeners_mutex);
    for_each (listeners.begin(), listeners.end(), /* call semGive()... */ )
}

这种方法确保永远不会错过任何信号。缺点是需要额外的系统资源。 为了避免为每个调用创建和销毁信号量，可以使用池。wait_for()wait_for()