NAME    [Toc]    [Back]

       pthread_cond_timedwait  -  Causes a thread to wait for the
       specified condition variable  to  be  signaled  or  broadcasted,
  such  that it will awake after a specified period
       of time

SYNOPSIS    [Toc]    [Back]

       #include <pthread.h>

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

LIBRARY    [Toc]    [Back]

       DECthreads POSIX 1003.1c Library (libpthread.so)

STANDARDS    [Toc]    [Back]

       Interfaces documented on this reference  page  conform  to
       industry standards as follows:

       IEEE  Std  1003.1c-1995,  POSIX System Application Program
       Interface

PARAMETERS    [Toc]    [Back]

       Condition variable  that  the  calling  thread  waits  on.
       Mutex  associated with the condition variable specified in
       cond.  Absolute time at which the  wait  expires,  if  the
       condition  has  not been signaled or broadcasted.  See the
       pthread_get_expiration_np(3) routine,  which  is  used  to
       obtain  a value for this argument. The abstime argument is
       specified in Universal Coordinated Time (UTC). In the UTCbased
  model,  time  is  represented  as seconds since the
       Epoch. The Epoch is defined as the time 0  hours,  0  minutes,
  0 seconds, January 1st, 1970 UTC. Seconds since the
       Epoch is a value interpreted  as  the  number  of  seconds
       between a specified time and the Epoch.

DESCRIPTION    [Toc]    [Back]

       This routine causes a thread to wait until one of the following
 occurs: The specified condition  variable  is  signaled
  or  broadcasted.   The current system clock time is
       greater than or equal to the time specified by the abstime
       argument.

       This  routine is identical to pthread_cond_wait(3), except
       that this routine can return before a  condition  variable
       is  signaled or broadcasted; specifically, when the specified
  time  expires.  For  more   information,   see   the
       pthread_cond_wait(3) description.

       This  routine atomically releases the mutex and causes the
       calling thread to wait on the condition. When  the  thread
       regains  control  after calling pthread_cond_timedwait(3),
       the mutex is locked and the thread is the owner.  This  is
       true regardless of why the wait ended. If general cancelability
 is enabled, the thread reacquires the mutex (blocking
  for  it if necessary) before the cleanup handlers are
       run (or before the exception is raised).

       If the current time equals or exceeds the expiration time,
       this    routine   returns   immediately,   releasing   and
       reacquiring the mutex. It might cause the  calling  thread
       to  yield (see the sched_yield(3) description).  Your code
       should check  the  return  status  whenever  this  routine
       returns  and take the appropriate action. Otherwise, waiting
 on the condition variable  can  become  a  nonblocking
       loop.

       Call  this  routine after you have locked the mutex specified
 in mutex. The results  of  this  routine  are  unpredictable
  if  this routine is called without first locking
       the mutex. The only routines which are supported  for  use
       with  asynchronous  cancelability  enabled are those which
       disable asynchronous cancelability.

RETURN VALUES    [Toc]    [Back]

       If an error condition  occurs,  this  routine  returns  an
       integer  value  indicating  the  type  of  error. Possible
       return values are as follows: Successful completion.   The
       value specified by cond, mutex, or abstime is invalid, or:
       Different   mutexes   are    supplied    for    concurrent
       pthread_cond_timedwait(3)           operations          or
       pthread_cond_wait(3)  operations  on  the  same  condition
       variable,  or:  The  mutex  was  not  owned by the calling
       thread at the time of the call.   The  time  specified  by
       abstime  expired.  DECthreads cannot acquire memory needed
       to block using a statically  initialized  condition  variable.

ERRORS    [Toc]    [Back]

       None

SEE ALSO    [Toc]    [Back]

       Functions:                      pthread_cond_broadcast(3),
       pthread_cond_destroy(3),             pthread_cond_init(3),
       pthread_cond_signal(3),              pthread_cond_wait(3),
       pthread_get_expiration_np(3)

       Manuals: Guide to DECthreads and Programmer's Guide



                                        pthread_cond_timedwait(3)