When a given thread waits (pthread_cond_wait() or pthread_cond_timedwait()) on a condition variable, it can be awakened as result of a signal operation (pthread_cond_signal()). However, if multiple threads are waiting on the same condition variable, any of those threads can be picked up by the scheduler to be woken up awaked (assuming that all threads have the same priority level and also that they have only one mutex associated with the condition variable CON37-C. Do not use more than one mutex for concurrent waiting operations on a condition variable).
This forces the user to create a predicate-testing-loop around the wait condition to guarantee that each thread only executes if its predicate test is true (recommendation on IEEE Std 1003.1 since 2001 release). As a consequence, if a given thread finds the predicate test to be false, it waits again, eventually resulting in a deadlock situation.
...
In the above code, each thread has its own predicate because each requires time to have a different value before proceeding.
Having Having into consideration that upon the signal operation (pthread_cond_signal()) any of the waiting threads can wake up and that if by chance it is not the one with the next step value, that one will wait again pthread_cond_wait(), thus resulting in a deadlock situation because no more signal operations will occur.
Therefore, this noncompliant code example violates the liveness property.
...
Compliant Solution (using pthread_cond_signal() but with a unique condition variable per thread)
One Another way to solve the signal issue is to use a unique condition variable for each thread (maintaining a single mutex associated with it). In this case, the signal operation (pthread_cond_signal()) will wake up the only thread waiting on it.
Note that NOTE: the predicate of the signaled thread must be true, otherwise a deadlock may occur anyway).
| Code Block | ||
|---|---|---|
| ||
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#define NTHREADS 5
pthread_mutex_t mutex;
pthread_cond_t cond[NTHREADS];
int main(int argc, char** argv) {
int i;
int result;
pthread_attr_t attr;
pthread_t threads[NTHREADS];
int step[NTHREADS];
if ((result = pthread_mutex_init(&mutex, NULL)) != 0) {
/* Handle error condition */
}
for (i = 0; i< NTHREADS; i++) {
if ((result = pthread_cond_init(&cond[i], NULL)) != 0) {
/* Handle error condition */
}
}
if ((result = pthread_attr_init(&attr)) != 0) {
/* Handle error condition */
}
if ((result = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE)) != 0) {
/* Handle error condition */
}
/* Create threads */
for (i = 0; i < NTHREADS; i++) {
step[i] = i;
if ((result = pthread_create(&threads[i], &attr, run_step, (void *)step[i])) != 0) {
/* Handle error condition */
}
}
/* Wait for all threads to complete */
for (i = NTHREADS-1; i >= 0; i--) {
if ((result = pthread_join(threads[i], NULL)) != 0) {
/* Handle error condition */
}
}
if ((result = pthread_mutex_destroy(&mutex)) != 0) {
/* Handle error condition */
}
for (i = 0; i < NTHREADS; i++) {
if ((result = pthread_cond_destroy(&cond[i])) != 0) {
/* Handle error condition */
}
}
if ((result = pthread_attr_destroy(&attr)) != 0) {
/* Handle error condition */
}
pthread_exit(NULL);
}
void *run_step(void *t) {
static int time = 0;
int step = (int)t;
int result;
if ((result = pthread_mutex_lock(&mutex)) != 0) {
/* Handle error condition */
}
printf("Thread %d has the lock\n", step);
while (time != step) {
printf("Thread %d is sleeping...\n", step);
if ((result = pthread_cond_wait(&cond[step], &mutex)) != 0) {
/* Handle error condition */
}
printf("Thread %d woke up\n", step);
}
/* Do processing... */
printf("Thread %d is processing...\n", step);
time++;
/* Signal next step thread */
if ((step + 1) < NTHREADS) {
if ((result = pthread_cond_signal(&cond[step+1])) != 0) {
/* Handle error condition */
}
}
printf("Thread %d is exiting...\n", step);
if ((result = pthread_mutex_unlock(&mutex)) != 0) {
/* Handle error condition */
}
pthread_exit(NULL);
}
|
...
Guideline | Severity | Likelihood | Remediation Cost | Priority | Level |
|---|---|---|---|---|---|
CON38-C | low | unlikely | medium | P2 | L3 |
...
Other Languages
This rule is a translation from the [THI04-J. Notify all waiting threads instead of a single thread|THI04-J.
Bibliography
| Wiki Markup |
|---|
\[[Open Group|AA. Bibliography#OpenGroup04]\] [pthread_cond_signal() pthread_cond_broadcast()|http://www.opengroup.org/onlinepubs/7990989775/xsh/pthread_cond_signal.html]\\ |
...
CON37-C. Do not use more than one mutex for concurrent waiting operations on a condition variable 14. Concurrency (CON) 49. Miscellaneous (MSC)