---

Table of Contents

1. What Is A Thread?
2. What Are Pthreads?
3. The Pthreads API
4. Classification Of Pthreads Calls
5. Simple Explanation Of A Mutex
6. Simple Explanation Of Condition Variables
7. Informal Classification Of Pthreads Functions

---

What Is A Thread?

• A thread is a stream of instructions that can be scheduled as an independent unit. It is easier to understand a thread within the context of a process.

• A process is created by an operating system; a process contains information about resources, such as process id, file descriptors, etc.; in addition it contains information pertaining to the execution state, such as program counter and stack.

• The concept of a thread requires that we make a separation between these two kinds of information in a process:
  • resources - these are available to the entire process e.g., program instructions, global data, working directory, etc..
  • schedulable entities - these would include program counters and stacks.
  A thread is an entity within a process which consists of the schedulable part of the process.

• Each process can have many threads which share the resources within a process (address space, for example). As compared to the cost of creating a process, a thread can be created with much less expense, because there is much less intervention on the part of the operating system.

---

What Are Pthreads?

• An unambiguously defined interface is essential if threads are to be useful to programmers that wish to take advantage of the capabilities provided by threads.

• While hardware vendors each have their own implementation of threads which differ from one another, the emerging standard on Unix systems is specified by IEEE POSIX 1003.1c -1995. A threads implementation that follows this standard is referred to as Pthreads. Most hardware vendors now tend to offer Pthreads. in addition to their proprietary API's.

• There are several drafts of the above standard, and AIX version 4.1 follows draft 7 of the POSIX standard. It is important to be aware of the draft number of a given implementation, because there are differences between drafts which can cause problems.

• Note that Windows NT does not follow the POSIX standard for threads but has its own proprietary implementation. Also, the Solaris 2 operating system follows the Unix International standard for its thread implementation which is slightly different from the POSIX standard.

---

The Pthreads API

• The API is defined in the ANSI/IEEE POSIX 1003.1 - 1995 standard. As compared to MPI, this standard is not freely available on the Web, and must be purchased from IEEE. An immediate consequence is that a full listing of the Pthread functions is not readily available.

• A number of excellent books contain sections that give a relatively complete list of the function calls in one place. These are listed at the end of this section.

• Because the API is not very large, the approach we will take to get familiar with this API is to list the various functions and classify them according to functionality. Of these we will then consider those that are most likely to be immediately useful

---

Classification Of Pthreads Calls

• To classify the calls to the Pthreads functions, we will use a scheme that is implicit in the standard which uses a naming scheme that is based on functionality.

• The concept of opaque objects pervades the design of the API. The basic calls work to create or modify opaque objects - the opaque objects can be modified by calls to attribute functions, which deal with opaque attributes.

• The three major classes of calls are the following:

  1. The first class of functions work directly on threads - creating, detaching, joining, etc.

     These are adjoined by thread attribute functions that set or modify attributes of the threads, (joinable, scheduling etc.)

  2. The second class of functions work on mutexes - creating, destroying, locking and unlocking.

     These are supplemented by mutex attribute functions that set or modify attributes associated with mutexes.

  3. The third class work on condition variables - creating and destroying, waiting and signalling.

     As before these are accompanied by condition variable attribute functions that modify or set attributes of condition variables, (e.g. shared or non-shared).

---

Simple Explanation Of A Mutex

• Mutex is a shortened form of the words "mutual exclusion". The basic concept of a mutex as used in Pthreads is that only one thread can lock (or own) a mutex at any given time. Thus, even if several threads try to lock a mutex only one thread will be successful. No other thread can own that mutex until the owning thread unlocks that mutex.

• A typical sequence in the use of a mutex is as follows:
  • Create a mutex
  • Several threads attempt to lock the mutex
  • Only one succeeds and that thread owns the mutex
  • The owner thread performs some set of actions
  • The owner unlocks the mutex
  • Another thread acquires the mutex and repeats the process
  • Finally the mutex is destroyed

• Very often the action performed by a thread owning a mutex is the updating of global variables. This is a safe way to ensure that when several threads update the same variable, the final value is the same as what it would be if only one thread performed the update. The variables being updated belong to a "critical section".

• When several threads compete for a mutex, the losers block at that call - an unblocking call is available with "trylock" instead of the "lock" call.

---

Simple Explanation Of Condition Variables

• Very often we encounter situations where a thread needs to wait on a certain condition to be met before it can proceed with its own task. A typical situation would be where one thread requires data from another thread before it can proceed.

• One approach would be to have one thread constantly polling (possibly in a critical section), to check if the condition is met. However this can be very resource consuming since that thread is continuously busy in this activity. A condition variable is a way to achieve the same goal.

• A condition variable is used in conjunction with a mutex lock and a predicate (typically a Boolean variable) to allow one thread to signal (or wake up) other threads which are waiting on that condition variable.

• The typical sequence for using condition variables:
  • Create a condition variable
  • Create an associated mutex and define a predicate variable

  Waiting on a condition variable

  • Lock the mutex
  • While predicate is unchanged wait on condition variable
  • Do work
  • Unlock the mutex

  Signalling on a condition variable

  • Lock the mutex
  • Do work
  • Change predicate
  • Signal on the condition variable
  • Unlock mutex

---

Informal Classification Of Pthreads Functions

1. Pthread Functions
   1. Basic thread management
      1. pthread_create -- Creates threads
      2. pthread_exit -- Exits a thread
      3. pthread_join -- Joins with a thread
      4. pthread_once -- Executes only once
      5. pthread_kill -- Kills a thread
      6. pthread_self -- Provides handle of calling thread
      7. pthread_equal -- Checks for equality of two threads
      8. pthread_yield -- Yields to others of same priority
      9. pthread_detach -- Detaches a thread

   2. Thread-specific data
      1. pthread_key_create
      2. pthread_key_delete
      3. pthread_getspecific
      4. pthread_setspecific

   3. Thread cancellation
      1. pthread_cancel
      2. pthread_cleanup_pop
      3. pthread_cleanup_push
      4. pthread_setcancelstate
      5. pthread_getcancelstate
      6. pthread_testcancel

   4. Thread scheduling
      1. pthread_getschedparam
      2. pthread_setschedparam

   5. Signals
      1. pthread_sigmask

2. Pthread Attribute Functions
   1. Basic management
      1. pthread_attr_init
      2. pthread_attr_destroy

   2. Detachable or joinable
      1. pthread_attr_setdetachstate
      2. pthread_attr_getdetachstate

   3. Specifying stack information
      1. pthread_attr_getstackaddr
      2. pthread_attr_getstacksize
      3. pthread_attr_setstackaddr
      4. pthread_attr_setstacksize

   4. Thread scheduling attributes
      1. pthread_attr_getschedparam
      2. pthread_attr_setschedparam
      3. pthread_attr_getschedpolicy
      4. pthread_attr_setschedpolicy
      5. pthread_attr_setinheritsched
      6. pthread_attr_getinheritsched
      7. pthread_attr_setscope
      8. pthread_attr_getscope

3. Mutex Functions
   1. Basic mutex management
      1. pthread_mutex_init
      2. pthread_mutex_destroy
      3. pthread_mutex_lock
      4. pthread_mutex_unlock
      5. pthread_mutex_trylock

   2. Priority management
      1. pthread_mutex_setprioceiling
      2. pthread_mutex_getprioceiling

4. Mutex Attribute Functions
   1. Basic mutex management
      1. pthread_mutexattr_init
      2. pthread_mutexattr_destroy

   2. Sharing
      1. pthread_mutexattr_getpshared
      2. pthread_mutexattr_setpshared

   3. Protocol attributes
      1. pthread_mutexattr_getprotocol
      2. pthread_mutexattr_setprotocol

   4. Priority management
      1. pthread_mutexattr_setprioceiling
      2. pthread_mutexattr_getprioceiling

5. Condition Variable Functions
   1. Basic condition variable management
      1. pthread_cond_init
      2. pthread_cond_destroy
      3. pthread_cond_signal
      4. pthread_cond_broadcast
      5. pthread_cond_wait
      6. pthread_cond_timedwait

6. Condition variable Attribute Functions
   1. Basic mutex management
      1. pthread_condattr_init
      2. pthread_condattr_destroy

   2. Sharing
      1. pthread_condattr_getpshared
      2. pthread_condattr_setpshared

---