|
|
cc [options] -Kthread file#include <pthread.h>
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);
pthread_cond_timedwait, similar to pthread_cond_wait, blocks the calling thread at the condition variable pointed to by cond, to wait for the occurrence of a condition. However, if the absolute time denoted by abstime has passed and the indicated condition is not signaled, pthread_cond_timedwait returns ETIMEDOUT to the caller.
The calling thread must lock the mutual exclusion lock (mutex) pointed to by mutex before calling pthread_cond_wait or pthread_cond_timedwait, otherwise the behavior is unpredictable.
pthread_cond_wait or pthread_cond_timedwait atomically releases the mutex and waits on the condition variable cond. When the condition is signaled (via pthread_cond_signal) or a signal is delivered to a thread waiting for a condition variable, pthread_cond_wait or pthread_cond_timedwait reacquires the mutex and returns zero. If the time expires, pthread_cond_timedwait returns ETIMEDOUT.
User-visible timers are not affected by a call to pthread_cond_timedwait.
The calling thread can resume execution when the condition is signaled or broadcast, a timeout occurs, or when interrupted. The logical condition should always be checked on return, as a return might not have been caused by a change in the condition.
cond and mutex must previously have been initialized (see pthread_cond_init(PTHREAD)).
mutex is a mutual exclusion variable protecting a shared resource associated with the condition represented by the condition variable, cond. The calling thread must lock mutex before calling pthread_cond_wait or pthread_cond_timedwait, otherwise the behavior is unpredictable.
abstime represents the time at which pthread_cond_timedwait
should time out.
The time is expressed in elapsed seconds and nanoseconds since
Universal Coordinated Time, January 1, 1970.
gettimeofday(S)
returns the current time,
but in seconds and microseconds.
To construct abstime, convert the current time to a
struct timespec, and add to that the waiting time.
A wait for a condition, either timed or untimed, is a cancelletion point. When the cancelability enable state of a thread is set to PTHREAD_CANCEL_DEFERRED, acting on a cancellation request while in a condition wait causes the mutex to be reacquired before calling the first cancellation cleanup handler. The behavior is as if the thread were unblocked, allowed to execute up to the return from the call to pthread_cond_wait or pthread_cond_timedwait, but at that point sees the cancellation request and starts the thread cancellation activities, instead of returning to the caller. (See pthread_cancel(PTHREAD).)
Because the condition can change between the time the condition is signaled and the mutex is relocked, the calling thread must always recheck the condition upon return from pthread_cond_wait or pthread_cond_timedwait.