POSIX Threads, usually referred to as Pthreads, is a POSIX standard for threads. The standard, POSIX.1c, Threads extensions (IEEE Std 1003.1c-1995), defines an API for creating and manipulating threads.

Implementations of the API are available on many Unix-like POSIX-conformant operating systems such as FreeBSD, NetBSD, OpenBSD, Linux, Mac OS X and Solaris. DR-DOS and Microsoft Windows implementations also exist: within the SFU/SUA subsystem which provides a native implementation of a number of POSIX APIs, and also within third-party packages such as pthreads-w32,^[1] which implements pthreads on top of existing Windows API.

Contents

Pthreads defines a set of C programming language types, functions and constants. It is implemented with a pthread.h header and a thread library.

There are around 100 Pthreads procedures, all prefixed "pthread_" and they can be categorized into four groups:

• Thread management - creating, joining threads etc.
• Mutexes
• Condition variables
• Synchronization between threads using read/write locks and barriers

The POSIX semaphore API works with POSIX threads but is not part of threads standard, having been defined in the POSIX.1b, Real-time extensions (IEEE Std 1003.1b-1993) standard. Consequently the semaphore procedures are prefixed by "sem_" instead of "pthread_".

Example

An example illustrating the use of Pthreads in C:

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
 
#define NUM_THREADS     5
 
void *perform_work(void *argument)
{
   int passed_in_value;
 
   passed_in_value = *((int *) argument);
   printf("Hello World! It's me, thread with argument %d!\n", passed_in_value);
 
   /* optionally: insert more useful stuff here */
 
   return NULL;
}
 
int main(void)
{
   pthread_t threads[NUM_THREADS];
   int thread_args[NUM_THREADS];
   int result_code, index;
 
   // create all threads one by one
   for (index = 0; index < NUM_THREADS; ++index) {
      thread_args[index] = index;
      printf("In main: creating thread %d\n", index);
      result_code = pthread_create(&threads[index], NULL, perform_work, (void *) &thread_args[index]);
      assert(0 == result_code);
   }
 
   // wait for each thread to complete
   for (index = 0; index < NUM_THREADS; ++index) {
      // block until thread 'index' completes
      result_code = pthread_join(threads[index], NULL);
      printf("In main: thread %d has completed\n", index);
      assert(0 == result_code);
   }
 
   printf("In main: All threads completed successfully\n");
   exit(EXIT_SUCCESS);
}

This program creates five threads, each executing the function perform_work that prints the unique number of this thread to standard output. If a programmer wanted the threads to communicate with each other, this would require defining a variable outside of the scope of any of the functions, making it a global variable.

POSIX Threads for Windows

Windows does not support the pthreads standard natively, therefore the Pthreads-w32 project seeks to provide a portable and open-source wrapper implementation. It can also be used to port Unix software (which use pthreads) with little or no modification to the Windows platform.^[2] With some additional patches the last version 2.8.0 is compatible with 64-bit Windows systems.^[3][4][5] 2.9.0 is said to also be 64-bit compatible.^[6]

The mingw-w64 project also contains a wrapper implementation of pthreads, winpthreads,^[7] which tries to use more native system calls than the Pthreads-w32 project.^[8]

Interix environment subsystem available in the Windows Services for UNIX/Subsystem for UNIX-based Applications package provides a native port of the pthreads API, i.e. not mapped on Win32/Win64 API but built directly on the operating system syscall interface.^[9]

See also

• OpenMP
• Cilk/Cilk Plus
• Threading Building Blocks (TBB)
• Native POSIX Thread Library (NPTL)
• DCEThreads
• clone (Linux system call)
• Spurious wakeup
• Thread-local storage
• GNU Portable Threads
• FSU Pthreads
• Grand Central Dispatch (Apple's thread library)
• Beginthread (a subroutine within Windows for creating a new thread and unix thread)
• State Threads, an event driven approach to threading

References

Further reading

• David R. Butenhof. Programming with POSIX Threads. Addison-Wesley. ISBN 0-201-63392-2. 
• Bradford Nichols, Dick Buttlar, Jacqueline Proulx Farell. Pthreads Programming. O'Reilly & Associates. ISBN 1-56592-115-1. 
• Charles J. Northrup. Programming with UNIX Threads. John Wiley & Sons. ISBN 0-471-13751-0. 
• Kay A. Robbins and Steven Robbins. UNIX Systems Programming. Prentice-Hall. ISBN 0-13-042411-0. 

External links

• The Open Group Base Specifications Issue 7, IEEE Std 1003.1
• HTML5 Presentation on Multi-Threading & POSIX Thread APIs