Почему функции условной переменной pthread требуют взаимного исключения?

Переменная условия довольно ограничена, если вы можете только сигнализировать об условии, обычно вам нужно обрабатывать некоторые данные, связанные с состояние, о котором было сообщено. Сигнализация / пробуждение должны выполняться атомарно, чтобы достичь этого без создания условий гонки, или быть чрезмерно сложными

pthreads также могут дать вам, по довольно техническим причинам, ложное пробуждение . Это означает, что вам нужно проверить предикат, чтобы быть уверенным, что условие действительно было сигнализировано, и отличить это от ложного пробуждения. Проверка такого условия в отношении ожидания его должна быть защищена - поэтому переменной условия нужен способ атомарного ожидания / пробуждения при блокировке / разблокировке мьютекса, охраняющего это условие.

Рассмотрим простой пример, когда вас уведомляют о создании некоторых данных.Возможно, другой поток создал какие-то данные, которые вам нужны, и установил указатель на эти данные.

Представьте, что поток-производитель передает некоторые данные другому потоку-потребителю через указатель some_data .

while(1) {
    pthread_cond_wait(&cond); //imagine cond_wait did not have a mutex
    char *data = some_data;
    some_data = NULL;
    handle(data);
}

вы, естественно, получите много условий гонки, что, если бы другой поток выполнил some_data = new_data сразу после того, как вы проснулись, но до того, как вы сделали data = some_data

You также не может создать свой собственный мьютекс для защиты этого случая. Например,

while(1) {

    pthread_cond_wait(&cond); //imagine cond_wait did not have a mutex
    pthread_mutex_lock(&mutex);
    char *data = some_data;
    some_data = NULL;
    pthread_mutex_unlock(&mutex);
    handle(data);
}

Не будет работать, все еще есть вероятность состояния гонки между пробуждением и захватом мьютекса. Размещение мьютекса перед pthread_cond_wait вам не поможет, так как теперь вы будете удерживать мьютекс во время ожидания - т.е. производитель никогда не сможет захватить мьютекс. (обратите внимание, в этом случае вы можете создать вторую условную переменную, чтобы сигнализировать производителю, что вы закончили с some_data - хотя это станет сложным, особенно если вам нужно много производителей / потребителей.)

Таким образом, вам нужен способ атомарно освободить / захватить мьютекс при ожидании / пробуждении из состояния. Это то, что делают переменные условия pthread, и вот что вы должны сделать:

while(1) {
    pthread_mutex_lock(&mutex);
    while(some_data == NULL) { // predicate to acccount for spurious wakeups,would also 
                               // make it robust if there were several consumers
       pthread_cond_wait(&cond,&mutex); //atomically lock/unlock mutex
    }

    char *data = some_data;
    some_data = NULL;
    pthread_mutex_unlock(&mutex);
    handle(data);
}

(производитель, естественно, должен будет принять те же меры предосторожности, всегда защищая some_data одним и тем же мьютексом и следя за тем, чтобы он не перезаписывал some_data, если some_data в настоящее время! = NULL)

Предполагается, что мьютекс заблокирован, когда вы вызываете pthread_cond_wait ; когда вы вызываете его атомарно, оба разблокируют мьютекс, а затем блокируют условие. Как только условие получено, оно снова атомарно блокирует его и возвращается.

Это позволяет при желании реализовать предсказуемое планирование, в котором поток, который будет выполнять сигнализацию, может ждать, пока мьютекс не будет освобожден, чтобы выполнить свою обработку, а затем сигнализировать об условии.