我有 3 个需要同步的进程。进程一做某事然后唤醒进程二并休眠，它做一些事然后唤醒进程三并休眠，它做某事并唤醒进程一并休眠。整个循环的定时运行在 25hz 左右（由于在我的“真实”应用程序中触发进程 2 之前，外部同步到进程 1）。我使用 sem_post 触发（唤醒）每个进程，并使用 sem_timedwait() 等待触发。
这一切都成功地工作了几个小时。然而，在某个随机时间（通常在两到四个小时之后），其中一个进程在 sem_timedwait() 中开始超时，即使我确信信号量是由 sem_post() 触发的。为了证明这一点，我什至在超时后立即使用 sem_getvalue() ，值为 1，因此应该触发了 timedwait。
请看以下代码：
#include <stdio.h>
#include <time.h>
#include <string.h>
#include <errno.h>
#include <semaphore.h>
sem_t trigger_sem1, trigger_sem2, trigger_sem3;
// The main thread process. Called three times with a different num arg - 1, 2 or 3.
void *thread(void *arg)
{
int num = (int) arg;
sem_t *wait, *trigger;
int val, retval;
struct timespec ts;
struct timeval tv;
switch (num)
{
case 1:
wait = &trigger_sem1;
trigger = &trigger_sem2;
break;
case 2:
wait = &trigger_sem2;
trigger = &trigger_sem3;
break;
case 3:
wait = &trigger_sem3;
trigger = &trigger_sem1;
break;
}
while (1)
{
// The first thread delays by 40ms to time the whole loop.
// This is an external sync in the real app.
if (num == 1)
usleep(40000);
// print sem value before we wait. If this is 1, sem_timedwait() will
// return immediately, otherwise it will block until sem_post() is called on this sem.
sem_getvalue(wait, &val);
printf("sem%d wait sync sem%d. val before %d\n", num, num, val);
// get current time and add half a second for timeout.
gettimeofday(&tv, NULL);
ts.tv_sec = tv.tv_sec;
ts.tv_nsec = (tv.tv_usec + 500000); // add half a second
if (ts.tv_nsec > 1000000)
{
ts.tv_sec++;
ts.tv_nsec -= 1000000;
}
ts.tv_nsec *= 1000; /* convert to nanosecs */
retval = sem_timedwait(wait, &ts);
if (retval == -1)
{
// timed out. Print value of sem now. This should be 0, otherwise sem_timedwait
// would have woken before timeout (unless the sem_post happened between the
// timeout and this call to sem_getvalue).
sem_getvalue(wait, &val);
printf("!!!!!! sem%d sem_timedwait failed: %s, val now %d\n",
num, strerror(errno), val);
}
else
printf("sem%d wakeup.\n", num);
// get value of semaphore to trigger. If it's 1, don't post as it has already been
// triggered and sem_timedwait on this sem *should* not block.
sem_getvalue(trigger, &val);
if (val <= 0)
{
printf("sem%d send sync sem%d. val before %d\n", num, (num == 3 ? 1 : num+1), val);
sem_post(trigger);
}
else
printf("!! sem%d not sending sync, val %d\n", num, val);
}
}
int main(int argc, char *argv[])
{
pthread_t t1, t2, t3;
// create semaphores. val of sem1 is 1 to trigger straight away and start the whole ball rolling.
if (sem_init(&trigger_sem1, 0, 1) == -1)
perror("Error creating trigger_listman semaphore");
if (sem_init(&trigger_sem2, 0, 0) == -1)
perror("Error creating trigger_comms semaphore");
if (sem_init(&trigger_sem3, 0, 0) == -1)
perror("Error creating trigger_vws semaphore");
pthread_create(&t1, NULL, thread, (void *) 1);
pthread_create(&t2, NULL, thread, (void *) 2);
pthread_create(&t3, NULL, thread, (void *) 3);
pthread_join(t1, NULL);
pthread_join(t2, NULL);
pthread_join(t3, NULL);
}
当程序正确运行时（开始时以及随机但很长时间之后），将打印以下输出。sem1 的值在 thread1 等待之前始终为 1，因为它休眠了 40 毫秒，此时 sem3 已触发它，因此它立即唤醒。其他两个线程等待，直到从前一个线程接收到信号量。
[...]
sem1 wait sync sem1. val before 1
sem1 wakeup.
sem1 send sync sem2. val before 0
sem2 wakeup.
sem2 send sync sem3. val before 0
sem2 wait sync sem2. val before 0
sem3 wakeup.
sem3 send sync sem1. val before 0
sem3 wait sync sem3. val before 0
sem1 wait sync sem1. val before 1
sem1 wakeup.
sem1 send sync sem2. val before 0
[...]
但是，几个小时后，其中一个线程开始超时。我可以从输出中看到信号量正在被触发，当我在超时后打印该值时，它是 1。所以 sem_timedwait 应该在超时之前就醒了。我永远不会期望信号量的值在超时后为 1，除非在非常罕见的情况下（几乎肯定不会，但这是可能的），即在超时之后但在我调用 sem_getvalue 之前发生触发器。
此外，一旦它开始失败，该信号量上的每个 sem_timedwait() 也会以同样的方式失败。请参阅以下输出，我已对其进行了行编号：
01 sem3 wait sync sem3. val before 0
02 sem1 wakeup.
03 sem1 send sync sem2. val before 0
04 sem2 wakeup.
05 sem2 send sync sem3. val before 0
06 sem2 wait sync sem2. val before 0
07 sem1 wait sync sem1. val before 0
08 !!!!!! sem3 sem_timedwait failed: Connection timed out, val now 1
09 sem3 send sync sem1. val before 0
10 sem3 wait sync sem3. val before 1
11 sem3 wakeup.
12 !! sem3 not sending sync, val 1
13 sem3 wait sync sem3. val before 0
14 sem1 wakeup.
[...]
在第 1 行，线程 3（我在 printf 中混淆地称为 sem3）等待 sem3 被触发。在第 5 行，thread2 为 sem3 调用 sem_post。但是，第 8 行显示 sem3 超时，但信号量的值为 1。thread3 然后触发 sem1 并再次等待 (10)。但是，因为值已经是 1，所以它会立即唤醒。它不会再次发送 sem1，因为这一切都是在将控制权交给 thread1 之前发生的，但是它会再次等待（val 现在为 0）并且 sem1 被唤醒。现在这会永远重复，sem3 总是超时并显示值为 1。
所以，我的问题是为什么 sem3 超时，即使信号量已被触发并且值显然是 1？我永远不会期望在输出中看到第 08 行。如果超时（因为线程 2 已经崩溃或耗时太长），该值应该为 0。为什么它在进入此状态之前先正常工作 3 或 4 小时？
我尝试过使用三个单独的程序进行类似的测试，通过共享内存进行通信，而不是同一个程序中的三个线程。这更接近于我的真实世界应用程序。结果和输出是一样的。问题确实出现在信号量（特别是 sem_timedwait 调用）中，而不是与 pthread 有任何关系。
我也尝试过更短和更长的延迟，以及完全消除延迟，结果与上述类似。没有任何延迟，它有时会在几分钟而不是几小时后开始产生错误。这当然意味着可以更快地重现问题。
这是使用带有内核 2.6.28 的 Ubuntu 9.4。相同的程序在 Redhat 和 Fedora 上运行正常，但我现在正在尝试移植到 Ubuntu。我也尝试过使用 Ubuntu 9.10，但没有任何区别。
感谢您的任何建议，贾尔斯