Thread Creation

• The Pthreads API subroutines can be informally grouped into four major groups:
  1. Thread management: Routines that work directly on threads - creating, detaching, joining, set/query thread attributes (joinable, scheduling etc.), etc.
  2. Mutexes: Routines that deal with synchronization. Mutex functions provide for creating, destroying, locking and unlocking mutexes, setting or modifying attributes associated with mutexes.
  3. Condition variables: Routines that address communications between threads that share a mutex. Functions to create, destroy, wait and signal based upon specified variable values, set/query condition variable attributes.
  4. Synchronization: Routines that manage read/write locks and barriers.

• Creating Threads:
• Initially, main program contains a single, default thread.
• pthread_create creates a new thread and makes it executable.

  1   #include <pthread.h> 
  2   int 
  3   pthread_create ( 
  4       pthread_t   *thread_handle, 
  5       const pthread_attr_t   *attribute, 
  6       void *   (*thread_function)(void *), 
  7       void   *arg);
  

• Creates a single thread that corresponds to the invocation of the function thread_function (and any other functions called by thread_function).
• Once created, threads are peers, and may create other threads.
• On successful creation of a thread, a unique identifier is associated with the thread and assigned to the location pointed to by thread_handle.
• On successful creation of a thread, pthread_create returns 0; else it returns an error code.

• The thread has the attributes described by the attribute argument.
• When this argument is NULL, a thread with default attributes is created.
• Some of these ''default'' attributes can be changed by the programmer via the thread attribute object.
• pthread_attr_init and pthread_attr_destroy are used to initialize/ destroy the thread attribute object.
• The arg field specifies a pointer to the argument to function thread_function.
• This argument is typically used to pass the workspace and other thread-specific data to a thread.

• There is no implied hierarchy or dependency between threads.
• Unless you are using the Pthreads scheduling mechanism, it is up to the implementation and/or OS to decide where and when threads will execute.
• If the thread is scheduled on the same processor, the new thread may, in fact, preempt its creator.
• This is important because all thread initialization procedures must be completed before creating the thread.
• This is a very common class of errors caused by race conditions for data access that shows itself in some execution instances, but not in others.
• Robust programs should not depend upon threads executing in a specific order.