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 ( pthread_t   *thread_handle, 
      4     const pthread_attr_t   *attribute, 
      5     void *   (*thread_function)(void *), 
      6     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.
• 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.
• Robust programs should not depend upon threads executing in a specific order.