There are three parameters related with pthread_cond_timedwait().

Definition:
int pthread_cond_timedwait(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex,
const struct timespec *restrict abstime);

Parameters:
pthread_cond_t *restrict cond : the condition you want to trigger this flow
pthread_mutex_t *restrict mutex : Mutual exclusion
const struct timespec *restrict abstime : absolutely waiting time ( = system time + waiting

【Step by Step】

Initial the mutex:
1. pthread_mutex_init(pthread_mutex_t *restrict  __mutex ,
              const pthread_mutexattr_t *restrict __mutex_attr);
　　 __mutex_attr can be NULL.
　　 __mutex_attr is the parameter about mutex.
　　If it is not NULL, go to “2.”
2. pthread_mutexattr_init(pthread_mutexattr_t * __mutex_attr );
　pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type);
　　 type: PTHREAD_MUTEX_RECURSIVE,
　　　　　 PTHREAD_MUTEX_NORMAL ……
3. pthread_cond_init(pthread_cond_t *restrict __cond ,
const pthread_condattr_t *restrict __cond_attr);

Start to wait for signal ” __cond “:
1. lock mutex: pthread_mutex_lock(&__mutex)
2. pthread_cond_timedwait(&__cond, &__mutex, &__abstime)
3. unlock mutex: pthread_mutex_unlock(&__mutex)

Start to send the signal ” __cond “:
1. lock mutex: pthread_mutex_lock(&__mutex)
2. pthread_cond_signal (&__cond)
3. unlock mutex: pthread_mutex_unlock(&__mutex)

Destroy the mutex:
1. pthread_mutex_destroy( pthread_mutex_t *restrict  __mutex );
2. pthread_mutexattr_destroy( pthread_mutexattr_t * __mutex_attr );
3. pthread_cond_destroy( pthread_cond_t *restrict __cond );

E.g.

// This thread will wait the signal.
void thread1(void *arg){
　int inArg = (int)arg;
　int ret = 0;
　struct timeval now;
　struct timespec outtime;

　pthread_mutex_lock(&g_mutex);

　gettimeofday(&now, NULL);
　outtime.tv_sec = now.tv_sec + 5;
　outtime.tv_nsec = now.tv_usec * 1000;
　ret = pthread_cond_timedwait(&g_cond, &g_mutex, &outtime);

　pthread_mutex_unlock(&g_mutex);
}


int main(void)
{
　pthread_t id1;
　int ret;

　// Initial mutex
　pthread_cond_init(&g_cond, NULL);
　pthread_mutex_init(&g_mutex, NULL);
　ret = pthread_create(&id1, NULL, (void *)thread1, (void *)1);

　if (0 != ret){
　　printf(“thread 1 create failed!\n”);
　　return 1;
　}

　printf(“Waiting %ds send the signal!\n”, SENDSIGTIME);
　sleep(SENDSIGTIME);

　// send the signal
　pthread_mutex_lock(&g_mutex);
　pthread_cond_signal(&g_cond);
　pthread_mutex_unlock(&g_mutex);
　pthread_join(id1, NULL);

　//Destroy the mutex
　pthread_cond_destroy(&g_cond);
　pthread_mutex_destroy(&g_mutex);
　return 0;
}

References:
https://blog.csdn.net/dead_g/article/details/73338960
https://linux.die.net/man/3/pthread_cond_timedwait
https://linux.die.net/man/3/pthread_cond_init
https://blog.csdn.net/yasi_xi/article/details/19112077