Tcl_ConditionNotify, Tcl_ConditionWait, Tcl_ConditionFinalize, Tcl_Get-
       ThreadData, Tcl_MutexLock, Tcl_MutexUnlock, Tcl_MutexFinalize, Tcl_Cre-
       ateThread, Tcl_JoinThread - Tcl thread support.


       #include <tcl.h>


       Tcl_ConditionWait(condPtr, mutexPtr, timePtr)


       Void *
       Tcl_GetThreadData(keyPtr, size)




       Tcl_CreateThread(idPtr, threadProc, clientData, stackSize, flags)

       Tcl_JoinThread(id, result)


       Tcl_Condition       *condPtr  (in)      A   condition  variable,  which
                                               must be associated with a mutex

       Tcl_Mutex           *mutexPtr (in)      A mutex lock.

       Tcl_Time            *timePtr  (in)      A  time  limit on the condition
                                               wait.  NULL  to  wait  forever.
                                               Note  that a polling value of 0
                                               seconds   doesn't   make   much

       Tcl_ThreadDataKey   *keyPtr   (in)      This   identifies  a  block  of
                                               thread local storage.  The  key
                                               should  be  static and process-
                                               wide, yet each thread will  end
                                               up   associating   a  different
                                               block of storage with this key.

       int                 *size     (in)      The  size  of  the thread local
                                               storage block.  This amount  of
                                               data  is allocated and initial-
                                               ized to  zero  the  first  time
                                               each   thread   calls  Tcl_Get-

       Tcl_ThreadId        *idPtr    (out)     The referred storage will  con-
                                               tain  the  id of the newly cre-
                                               ated thread as returned by  the
                                               operating system.

       Tcl_ThreadId        id        (in)      Id of the thread waited upon.

       Tcl_ThreadCreateProc          threadProc(in)
                                               This  procedure will act as the
                                               main()  of  the  newly  created
                                               thread.  The  specified client-
                                               Data will be its sole argument.

       ClientData          clientData(in)      Arbitrary  information.  Passed
                                               as sole argument to the thread-

       int                 stackSize (in)      The  size of the stack given to
                                               the new thread.

       int                 flags     (in)      Bitmask containing flags allow-
                                               ing the caller to modify behav-
                                               iour of the new thread.

       int                 *result   (out)     The referred storage is used to
                                               place  the  exit  code  of  the
                                               thread waited upon into it.


       Beginning with the 8.1 release, the Tcl  core  is  thread  safe,  which
       allows  you  to incorporate Tcl into multithreaded applications without
       customizing the Tcl core.  To enable Tcl  multithreading  support,  you
       must  include the --enable-threads option to configure when you config-
       ure and compile your Tcl core.

       An important constraint of the Tcl threads implementation is that  only
       the thread that created a Tcl interpreter can use that interpreter.  In
       other words, multiple threads can not access the same Tcl  interpreter.
       (However,  as  was  the  case in previous releases, a single thread can
       safely create and use multiple interpreters.)

       Tcl does provide Tcl_CreateThread for creating threads. The caller  can |
       determine  the size of the stack given to the new thread and modify the |
       behaviour     through     the     supplied     flags.     The     value |
       TCL_THREAD_STACK_DEFAULT  for  the stackSize indicates that the default |
       size as specified by the operating system is to be  used  for  the  new |
       thread.   As   for   the   flags,   currently   are   only  the  values |
       TCL_THREAD_NOFLAGS and TCL_THREAD_JOINABLE defined. The first  of  them |
       invokes  the  default  behaviour  with no specialties. Using the second |
       value marks the new thread as joinable. This means that another  thread |
       can wait for the such marked thread to exit and join it.                |

       Restrictions: On some unix systems the pthread-library does not contain |
       the functionality to specify the stacksize of a thread.  The  specified |
       value  for  the stacksize is ignored on these systems. Both Windows and |
       Macintosh currently do not support joinable threads. This flag value is |
       therefore ignored on these platforms.

       Tcl  does provide Tcl_ExitThread and Tcl_FinalizeThread for terminating
       threads and  invoking  optional  per-thread  exit  handlers.   See  the
       Tcl_Exit page for more information on these procedures.

       The  Tcl_JoinThread  function is provided to allow threads to wait upon |
       the exit of another thread, which must have  been  marked  as  joinable |
       through  usage  of the TCL_THREAD_JOINABLE-flag during its creation via |
       Tcl_CreateThread.                                                       |

       Trying to wait for the exit of a non-joinable thread or a thread  which |
       is  already waited upon will result in an error. Waiting for a joinable |
       thread which already exited is possible, the  system  will  retain  the |
       necessary  information  until  after  the call to Tcl_JoinThread.  This |
       means that not calling Tcl_JoinThread for a joinable thread will  cause |
       a memory leak.

       Tcl  provides  Tcl_ThreadQueueEvent  and  Tcl_ThreadAlert  for handling
       event queueing in multithreaded applications.  See the Notifier  manual
       page for more information on these procedures.

       In this release, the Tcl language itself provides no support for creat-
       ing multithreaded scripts (for example, scripts that could spawn a  Tcl
       interpreter  in a separate thread).  If you need to add this feature at
       this time, see the tclThreadTest.c file in the Tcl source  distribution
       for an experimental implementation or use the Tcl "Threading Extension"
       package implementing thread creation and  management  commands  at  the
       script level.


       A mutex is a lock that is used to serialize all threads through a piece
       of code by calling Tcl_MutexLock and Tcl_MutexUnlock.   If  one  thread
       holds  a mutex, any other thread calling Tcl_MutexLock will block until
       Tcl_MutexUnlock is called.  A mutex can be destroyed after its  use  by |
       calling  Tcl_MutexFinalize.   The  result of locking a mutex twice from |
       the same thread is undefined.  On some platforms it will  result  in  a |
       deadlock.   The  Tcl_MutexLock,  Tcl_MutexUnlock  and Tcl_MutexFinalize
       procedures are defined as empty macros if not  compiling  with  threads
       enabled.  For declaration of mutexes the TCL_DECLARE_MUTEX macro should
       be used.  This macro assures correct mutex handling even when the  core
       is compiled without threads enabled.

       A  condition  variable  is  used as a signaling mechanism: a thread can
       lock a mutex and then wait on a condition variable with  Tcl_Condition-
       Wait.   This  atomically releases the mutex lock and blocks the waiting
       thread until another thread calls Tcl_ConditionNotify.  The  caller  of
       Tcl_ConditionNotify should have the associated mutex held by previously
       calling Tcl_MutexLock, but this is not enforced.  Notifying the  condi-
       tion  variable  unblocks all threads waiting on the condition variable,
       but they do not proceed until the mutex is released  with  Tcl_MutexUn-
       lock.   The implementation of Tcl_ConditionWait automatically locks the
       mutex before returning.

       The caller of Tcl_ConditionWait should be prepared for spurious notifi-
       cations  by  calling  Tcl_ConditionWait  within a while loop that tests
       some invariant.

       A condition variable can be destroyed after its use by calling Tcl_Con- |
       ditionFinalize.                                                         |

       The  Tcl_ConditionNotify,  Tcl_ConditionWait  and Tcl_ConditionFinalize |
       procedures are defined as empty macros if not  compiling  with  threads |

       The  Tcl_GetThreadData call returns a pointer to a block of thread-pri-
       vate data.  Its argument is a key that is shared by all threads  and  a
       size  for the block of storage.  The storage is automatically allocated
       and initialized to all zeros the first time each thread  asks  for  it.
       The storage is automatically deallocated by Tcl_FinalizeThread.


       All  of  these synchronization objects are self initializing.  They are
       implemented as opaque pointers that should be NULL upon first use.  The
       mutexes  and  condition variables are either cleaned up by process exit |
       handlers (if living that long) or explicitly by calls  to  Tcl_MutexFi- |
       nalize  or  Tcl_ConditionFinalize.   Thread  local storage is reclaimed
       during Tcl_FinalizeThread.


       The API to create threads is not finalized at  this  time.   There  are
       private  facilities  to  create  threads  that contain a new Tcl inter-
       preter, and to send scripts among threads.  Dive  into  tclThreadTest.c
       and tclThread.c for examples.


       Tcl_GetCurrentThread,  Tcl_ThreadQueueEvent, Tcl_ThreadAlert, Tcl_Exit-
       Thread,        Tcl_FinalizeThread,         Tcl_CreateThreadExitHandler,


       thread, mutex, condition variable, thread local storage

Tcl                                   8.1                           Threads(3)

Man(1) output converted with man2html