An Elementary Introduction to Pthreads

Vijay Sonnad IBM Corporation Austin, Texas 78758 USA

What Is A Thread?
What Are Pthreads?
The Pthreads API
Classification Of Pthreads Calls
Simple Explanation Of A Mutex
Simple Explanation Of Condition Variables
Informal Classification Of Pthreads Functions
Example program 1( from a book about threads)
Example program 2( from a book about threads)
Example program 3 (modified from the previous--> you can really see the the effect of mutex if you run this and the next)
Example program 4

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:

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.)

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.

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

Pthread Functions

Basic thread management

pthread_create -- Creates threads
pthread_exit -- Exits a thread
pthread_join -- Joins with a thread
pthread_once -- Executes only once
pthread_kill -- Kills a thread
pthread_self -- Provides handle of calling thread
pthread_equal -- Checks for equality of two threads
pthread_yield -- Yields to others of same priority
pthread_detach -- Detaches a thread

Thread-specific data

pthread_key_create
pthread_key_delete
pthread_getspecific
pthread_setspecific

Thread cancellation

pthread_cancel
pthread_cleanup_pop
pthread_cleanup_push
pthread_setcancelstate
pthread_getcancelstate
pthread_testcancel

Thread scheduling

pthread_getschedparam
pthread_setschedparam

Signals

pthread_sigmask

Pthread Attribute Functions

Basic management

pthread_attr_init
pthread_attr_destroy

Detachable or joinable

pthread_attr_setdetachstate
pthread_attr_getdetachstate

Specifying stack information

pthread_attr_getstackaddr
pthread_attr_getstacksize
pthread_attr_setstackaddr
pthread_attr_setstacksize

Thread scheduling attributes

pthread_attr_getschedparam
pthread_attr_setschedparam
pthread_attr_getschedpolicy
pthread_attr_setschedpolicy
pthread_attr_setinheritsched
pthread_attr_getinheritsched
pthread_attr_setscope
pthread_attr_getscope

Mutex Functions

Basic mutex management

pthread_mutex_init
pthread_mutex_destroy
pthread_mutex_lock
pthread_mutex_unlock
pthread_mutex_trylock

Priority management

pthread_mutex_setprioceiling
pthread_mutex_getprioceiling

Mutex Attribute Functions

Basic mutex management

pthread_mutexattr_init
pthread_mutexattr_destroy

Sharing

pthread_mutexattr_getpshared
pthread_mutexattr_setpshared

Protocol attributes

pthread_mutexattr_getprotocol
pthread_mutexattr_setprotocol

Priority management

pthread_mutexattr_setprioceiling
pthread_mutexattr_getprioceiling

Condition Variable Functions

Basic condition variable management

pthread_cond_init
pthread_cond_destroy
pthread_cond_signal
pthread_cond_broadcast
pthread_cond_wait
pthread_cond_timedwait

Condition variable Attribute Functions

Basic mutex management

pthread_condattr_init
pthread_condattr_destroy

Sharing

pthread_condattr_getpshared
pthread_condattr_setpshared