How does the pthread_cond_timedwait() function work?

Question

The purpose of this function is to show the hours, wait for 2 seconds, and show the hours again to make sure that 2 seconds have passed. I am not using sleeps as this function is to help me understand how the pthread_cond_timedwait function works so I can use it as a synchronization method.

//gcc -Wall -pthread timedwait.c -o  timedwait


#define _OPEN_THREADS                                                           
#include <pthread.h>                                                            
#include <stdio.h>                                                              
#include <time.h>                                                               
#include <errno.h>
#include <stdlib.h>


int main() {                                                                        
  pthread_cond_t cond;                                                          
  pthread_mutex_t mutex;                                                        
  time_t T;                                                                     
  struct timespec t;                                                            

  if (pthread_cond_init(&cond, NULL) != 0) {                                    
    perror("pthread_cond_init() error");                                        
    exit(2);                                                                    
  }                                                                             


  time(&T);                                                                     
  t.tv_sec = T + 2;                                                             
  printf("starting timedwait at %s", ctime(&T));                                
  pthread_cond_timedwait(&cond, &mutex, &t);                                                                                               
  time(&T);                                                                     
  printf("timedwait over at %s", ctime(&T));                                  
}

Answer 1

That’s how it works:

int main() {
  pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
  pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  time_t T;
  struct timespec t;

  time(&T);
  t.tv_sec = T + 2;
  t.tv_nsec = 0;
  printf("starting timedwait at %s", ctime(&T));
  pthread_mutex_lock(&mutex);
  pthread_cond_timedwait(&cond, &mutex, &t);
  time(&T);
  printf("timedwait over at %s", ctime(&T));
}

I think the main defect of his attempt was to forget to lock the mutex, which is an essential condition for pthread_cond_timedwait() to operate. (He also unlocks the mutex.)

pthread_cond_timedwait() works similar to a Sleep(2) in this example because it waits for the condition variable cond until the maximum time limit specified in the third parameter. Because it is a single-threaded program, no one will call pthread_cond_signal() and the result is that we will always wait 2 seconds, the condition variable just satisfies the caller and does nothing really.

Answer 2

I was helped in stackoverflow English, more information: Stackoverflow English

/ gcc -Wall -pthread timedwait.c -o  exe

#include <pthread.h>
#include <stdio.h>
#include <time.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>

int main() {
    pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    struct timespec t;
    int result;

    result = pthread_mutex_lock(&mutex);
    if (result != 0) {
        fprintf(stderr, "pthread_mutex_lock: %s\n", strerror(result));
        exit(EXIT_FAILURE);
    }

    result = clock_gettime(CLOCK_REALTIME, &t);
    if (result == -1) {
        perror("clock_gettime");
        exit(EXIT_FAILURE);
    }

    // Return-value check is non-essential here:
    printf("starting timedwait at %s", ctime(&t.tv_sec));

    t.tv_sec += 2;
    result = pthread_cond_timedwait(&cond, &mutex, &t);
    if (result != ETIMEDOUT) {
        fprintf(stderr, "%s\n", strerror(result));
    }

    result = clock_gettime(CLOCK_REALTIME, &t);
    if (result == -1) {
        perror("clock_gettime");
        exit(EXIT_FAILURE);
    }

    // Return-value check is non-essential here:
    printf("timedwait over at %s", ctime(&t.tv_sec));

    // Return-value check is non-essential here, because we'll just exit anyway:
    pthread_mutex_unlock(&mutex);
}