pthread_cond_wait/信号和互斥锁无法按预期工作

预期行为。 发出条件变量信号后，等待线程最终将唤醒并争用互斥锁，但不能保证信号线程无法在此发生之前重新获取互斥锁。

如果您希望计数器线程等待警报被消耗，则需要实际编程以执行此操作。 您可以反过来使用相同的条件变量 - 在计数器线程中：

if (pthread_cond_signal (&myarg->condition) >0)
{
    printf("COND SIGNAL ERRORn");
    pthread_exit(NULL);
}
pthread_mutex_lock (&myarg->mutex); /* We should get the lock again before testing/modifying any shared variable */
/* Wait for alarm to happen */
while (myarg->calls < myarg->iteration)
{
    pthread_cond_wait(&myarg->condition, &myarg->mutex);
}

在警报线程中，在递增myarg->calls后的某个时间点调用pthread_cond_signal(&myarg->condition)。

顺便说一下，您确实需要您在警报线程中注释掉的while(myarg->Counter<21)。 请考虑以下两种情况：

1. 警报线程在其主循环开始时的pthread_mutex_lock()处被阻塞。 计数器线程具有互斥锁，并且刚刚myarg->Counter递增到大于 20 的值。 它会解锁互斥锁并向条件变量发出信号，然后警报线程有机会运行。 然后，警报线程运行，获取互斥锁并阻塞pthread_cond_wait() - 它将永远在这里等待，因为我们现在已经确保计数器线程将等待警报被使用后再继续。

2. 报警线程刚刚将计数器递减为零，解锁互斥锁，立即将其重新锁定在循环顶部并调用pthread_cond_wait()。 pthread_cond_wait()在计数器线程有机会获取互斥锁之前立即返回（由于允许的"虚假唤醒"），并且即使计数器仍为零，警报线程现在也会继续。

这是工作版本，以防它对其他人有用：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

struct data
{
    int Counter = 0;
    int calls = -1;
    int iteration = -1;
    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    pthread_cond_t condition = PTHREAD_COND_INITIALIZER;
};
void* threadAlarm (void* arg);
void* threadCounter (void* arg);
int main (void)
{
    pthread_t monThreadCounter;
    pthread_t monThreadAlarm;
    struct data mydata;
    if (pthread_create (&monThreadAlarm, NULL, threadAlarm, (void*)&mydata)>0)
        printf("Pthread Alarme errorn");
    if (pthread_create (&monThreadCounter, NULL, threadCounter, (void*)&mydata)>0)
        printf("Pthread Counter errorn");
    pthread_join (monThreadCounter, NULL);
    pthread_join (monThreadAlarm, NULL);
    return 0;
}
void* threadCounter (void *arg)
{
    struct data *myarg = (struct data *)arg;
    srand(time(NULL));
    if (pthread_mutex_lock(&myarg->mutex) > 0)
        {
            printf("ERROR Mutex lock1 Countern");
            pthread_exit(NULL);
        }
    while(1)
    {
        myarg->Counter += rand()%10; /* We add a random number to the counter */
        if(myarg->Counter > 20) /* If Counter is greater than 20, we should trigger the alarm*/
        {
            myarg->iteration += 1; /* Iteration counter, to check any shift between expected triggers and reality */
            printf("Counter = %i(%i)-->",myarg->Counter,myarg->iteration);
            if (pthread_mutex_unlock(&myarg->mutex) > 0) /* Unlock mutex before sending signal */
                {
                    printf("ERROR Mutex Unlock Countern");
                    pthread_exit(NULL);
                }
            if (pthread_cond_signal (&myarg->condition) >0)
            {
                printf("COND SIGNAL ERRORn");
                pthread_exit(NULL);
            }
            if (pthread_mutex_lock(&myarg->mutex) > 0) /* We should get the lock again before testing/modifying any shared variable */
                {
                    printf("ERROR Mutex lock2 Countern");
                    pthread_exit(NULL);
                }
            /* Wait for alarm to happen */
            while (myarg->calls < myarg->iteration)
            {
                pthread_cond_wait(&myarg->condition, &myarg->mutex);
            }
        }
    }
}
void* threadAlarm (void* arg)
{
    struct data *myarg = (struct data *)arg;
    while(1)
    {
        if (pthread_mutex_lock(&myarg->mutex) > 0)
            {
                printf("ERROR Mutex lock Alarmn");
                pthread_exit(NULL);
            }
        while(myarg->Counter<21)
        {
            printf("nWAITING for trigger...n");
            if (pthread_cond_wait (&myarg->condition, &myarg->mutex)>0)
            {
                printf("ERROR COND WAITn");
                pthread_exit(NULL);
            }
        }
        myarg->calls+=1; // Calls counter, should be equal to iteration counter, overwise calls have been missed
        printf("ALARM TRIGGERED! Call #%i/Iteration #%i -> COUNTER RESETn",myarg->calls, myarg->iteration);
        // Counter reset
        myarg->Counter = 0;
        if (pthread_mutex_unlock(&myarg->mutex) > 0)
            {
                printf("ERROR Mutex Unlock Alarmn");
                pthread_exit(NULL);
            }

        if (pthread_cond_signal (&myarg->condition) >0) //Signal back to Counter thread
        {
            printf("COND SIGNAL ERRORn");
            pthread_exit(NULL);
        }
    }
}