POSIX.1 specifies a set of interfaces (functions, header files) for threaded programming commonly known as POSIX threads, or Pthreads. A single process can. The Single UNIX ® Specification, Version 2. Copyright © The Open Group. NAME. pthread.h - threads. SYNOPSIS. #include. DESCRIPTION. Jump to What is a Thread? - Think of sewing needles as the processors and the threads in a program as the thread fiber. If you had two needles but only.


Author: Amani Carter DDS
Country: Guatemala
Language: English
Genre: Education
Published: 13 November 2014
Pages: 119
PDF File Size: 35.74 Mb
ePub File Size: 1.70 Mb
ISBN: 424-9-58654-634-6
Downloads: 55174
Price: Free
Uploader: Amani Carter DDS


They impose some form of additional kernel overhead, lowering performance.

In almost posix threads situations, IPC is not a "natural" extension of your code. It often dramatically increases the complexity of your program.

If you've ever had to make massive modifications to one of your programs so that it supports IPC, you'll really appreciate the simple memory-sharing approach that posix threads provide.

POSIX Threads Programming

POSIX threads don't need to make expensive and complicated long-distance calls because all our threads happen to live in the same house. With a little synchronization, all your threads can read and modify your program's existing posix threads structures.

  • Pthreads(7) - Linux manual page
  • POSIX threads explained
  • Multithreaded Programming (POSIX pthreads Tutorial)
  • POSIX thread (pthread) libraries
  • POSIX Threads Programming

You don't have to pump the data through a file descriptor or squeeze it into a tight, shared memory space. Threads are nimble Posix threads there's more.

POSIX threads

Threads also happen to be extremely nimble. Compared to a standard forkthey carry a lot less overhead. The kernel does posix threads need to make a new independent copy of the posix threads memory posix threads, file descriptors, etc. That saves a lot of CPU time, making thread creation ten to a hundred times faster than new process creation.

Because of this, you can use a whole bunch of threads and not worry too much about the CPU and memory overhead incurred.

You don't have a big CPU hit the way you do with fork. This means you can generally create threads whenever it makes sense in your program. Although threads are lightweight, they still incur overhead when they are created.

Pipeline Similar to how pipelining works in a processor, each thread is part of a long chain in a processing factory. Each thread posix threads on data processed by the previous thread and hands it off to the next thread.

You must be careful to equally distribute work and take extra posix threads to ensure non-blocking behavior posix threads this thread model or you could experience pipeline "stalls.


It is unsafe to allow concurrent access to such data or posix threads without some mechanism that defines a protocol for safe access! Threads must be explicitly instructed to block when other threads may be potentially accessing the same resources.

Mutual Exclusion Mutual exclusion is the method of serializing access to shared resources. You do not want a thread posix threads be modifying a variable that is already in the process of being modified by another thread! Posix threads scenario is a dirty read where the value is in the process of being updated and another thread reads an old value.

Mutual exclusion allows the programmer to create a defined protocol for serializing access to shared data or resources.


Posix threads, a mutex is a lock that one can virtually attach to some resource. If a thread wishes to modify or read posix threads value from a shared resource, the thread must first gain the lock.

Once it has the lock it may do what it wants with the shared resource without concerns of other threads accessing the shared resource because other threads will have to wait. Once the thread finishes using the shared resource, it unlocks the mutex, which allows other threads to access the resource.

Linux Tutorial: POSIX Threads

This is a protocol that serializes access to the shared resource. Note that such a protocol must be enforced for the data or resource a mutex is protecting across all threads that may touch posix threads resource being protected.

If the protocol is violated e. There is nothing preventing a thread programmer, whether unintentionally most often the case, i. As an analogy, you can think of a mutex as a safe with only one key posix threads a standard mutex caseand the resource it is protecting lies within the safe.