Threads: Timeout lock - c

Question

Program description:
I wrote a demo for conditional waiting. The program starts two threads and then waits for both to finish. One of the threads reads user-pressed keys from the keyboard, and if the q key is pressed, sets a condition variable, after that the thread ends.
How can I implement the second thread to run in an infinite loop a sequence in which it waits for the condition variable for up to 1 second, and if the set variable appears then it exits the infinite loop, and if it does not appear and expires in 1 second, it displays a * on the console and returns to standby?
#include<pthread.h>
#include<stdio.h>
#include<stdio.h>
#include<unistd.h>
#include<errno.h>
pthread_mutex_t m=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c=PTHREAD_COND_INITIALIZER;
void *fun1()
{
pthread_mutex_lock(&m);
while (1)
{
char ch;
scanf("%c",&ch);
if(ch=='q')
{
pthread_mutex_unlock(&m);
pthread_cond_signal(&c);
pthread_exit(NULL);
}
}
}
void *fun2()
{
struct timespec to;
pthread_condattr_t attr;
pthread_condattr_init( &attr);
pthread_condattr_setclock( &attr, CLOCK_MONOTONIC);
pthread_cond_init( &c, &attr);
clock_gettime(CLOCK_MONOTONIC, &to);
to.tv_sec += 1;
while (1)
{
printf("hello world\n");
int rc=pthread_cond_timedwait(&c,&m,&to);
printf("%d",rc==ETIMEDOUT);
pthread_exit(NULL);
// if(rc==ETIMEDOUT)
// {
// }
// pthread_exit(NULL);
}
}
int main()
{
pthread_t id[2];
pthread_mutex_init(&m,NULL);
pthread_cond_init( &c, NULL);
pthread_mutex_lock(&m);
pthread_create(&id[0],NULL,fun1,NULL);
pthread_create(&id[1],NULL,fun2,NULL);
pthread_join(id[0],NULL);
pthread_join(id[1],NULL);
pthread_mutex_destroy(&m);
return 0;
}

Answer 1

The structure of the code looks at-best to be pure-guesswork. Pthread mutex and condition variable pairing has specific rolls and responsibilities.
The mutex protects some external 'predicate' data
The condition variable signals a change to 'predicate' data.
The management of both the mutex and the condition variable is completely wrong.
repeated initialization of the already-initialized objects.
acquiring, and never releasing the mutex in fun1
both functions have the wrong signature for proper pthread threads.
neither function provides state return values
Related, some pthread implementations do not support clock-selection. In those cases, even fixing the code, the condition variable cannot be configured for monotonic clock selection; realtime is the only alternative.
Fixing everything above,
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c = PTHREAD_COND_INITIALIZER;
bool quit = false;
void *fun1(void *pv)
{
while (1)
{
char ch;
scanf("%c", &ch);
if (ch == 'q')
{
// latch mutex before changing predicate
pthread_mutex_lock(&m);
quit = true;
pthread_cond_signal(&c);
pthread_mutex_unlock(&m);
break;
}
}
return pv;
}
void *fun2(void *pv)
{
pthread_mutex_lock(&m);
while (1)
{
printf("hello world\n");
struct timespec to;
clock_gettime(CLOCK_REALTIME, &to);
to.tv_sec += 1;
int rc = pthread_cond_timedwait(&c, &m, &to);
if (rc != ETIMEDOUT || quit == true)
break;
}
pthread_mutex_unlock(&m);
return pv;
}
int main()
{
pthread_t id[2];
pthread_create(id+0, NULL, fun1, NULL);
pthread_create(id+1, NULL, fun2, NULL);
pthread_join(id[0], NULL);
pthread_join(id[1], NULL);
return 0;
}
Pay close attention to how the mutex protects the predicate data (quit), and how that data is never checked, nor modified, without protection from that mutex by any thread. It's important.
Finally, note that fun1 (or fun2 ; pick one) is ultimately pointless in this code. Starting threads and waiting for them all to finish as the sole responsibility of main is a code smell that something can be done in main to avoid at least one of those threads. For example:
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c = PTHREAD_COND_INITIALIZER;
bool quit = false;
void *fun2(void *pv)
{
pthread_mutex_lock(&m);
while (1)
{
printf("hello world\n");
struct timespec to;
clock_gettime(CLOCK_REALTIME, &to);
to.tv_sec += 1;
int rc = pthread_cond_timedwait(&c, &m, &to);
if (rc != ETIMEDOUT || quit == true)
break;
}
pthread_mutex_unlock(&m);
return pv;
}
int main()
{
pthread_t id;
pthread_create(&id, NULL, fun2, NULL);
while (1)
{
char ch;
scanf("%c", &ch);
if (ch == 'q')
{
// latch mutex before changing predicate
pthread_mutex_lock(&m);
quit = true;
pthread_cond_signal(&c);
pthread_mutex_unlock(&m);
break;
}
}
pthread_join(id, NULL);
return 0;
}
Does exactly the same thing as the previous code, but uses main as the driver for what fun1 was originally doing. Always consider this as an option worth pursuing if you can. Be kind to your scheduler; it will return the favor someday.