POSIX Threads and Synchronization

POSIX Threads and Synchronization

• POSIX threads (pthreads) add threading to Unix
• Early Unix used a process model for concurrency, while POSIX threads share more resources like processes
• Every POSIX thread begins with a function

POSIX Synchronization

• Pthreads offer various synchronization mechanisms. A rich set of options is available
• Mutexes
• Semaphores
• Condition variables
• Thread joining
• Memory barriers (not discussed in detail)

Compilation with Pthreads

• Pthreads may require specific compiler/linker options during compilation and linking
• On modern Linux, use the -pthread option
• Other systems may require alternative options:
  • Different compiler or linker options (e.g., -pthreads)
  • Preprocessor defines (e.g., -DPTHREAD, -D_REENTRANT)
  • Linking with a library (e.g., -lpthread)
• Consult documentation for specific requirements

Thread Creation

• Threads are created using the pthread_create() function
• Syntax: int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_function) (void *), void *arg)
• The created thread:
  • Starts execution at the specified start function.
  • Has the provided data passed as an argument

Pthread Object Declarations

• Threads (and other Pthread objects) are declared as values, but are often used as pointers.
• Example: pthread_t thread; pthread_create(&thread, NULL, thread_function, NULL);
• This eliminates the need for dynamic allocation

Thread Functions

• Thread start functions have the following signature: void *(*start_function) (void* );
• This is a function that:
  • Accepts a single void * argument
  • Returns a void * value
• Example: void *thread_main(void *arg) { return NULL; }

Thread Semantics

• pthread_create() creates a new execution context (including a stack).
• It establishes a concurrent flow based on the provided stack and context.
• It then invokes the given function and passes the provided argument.
• The separation of function and arguments enables one function to handle diverse tasks.
• The new thread operates independently of the original thread.

Thread Attributes

• pthread_create() accepts a thread attribute object (pthread_attr_t)
• Using NULL implies using default attributes
• Attributes include:
  • Processor affinity
  • Desired scheduler, including configurations
  • Detach state of the new thread
  • Stack location and size
• Attributes will not be used in the current semester

Thread Termination

• POSIX threads can terminate in various ways:
  • Application exit
  • Returning from the thread's start function
  • Cancellation by another thread using pthread_cancel()

Thread Joining

• Joining a thread is a synchronous operation.
• pthread_join() blocks the caller until the target thread exits.
• It retrieves the thread's exit status.
  • Syntax: int pthread_join(pthread_t thread, void **retval);

Examples

• counter.c: Mutexes to protect critical sections
• deadlock.c: Deadlock scenarios
• odds_evens.c: Condition variables
• printer.c: Thread scheduling and joining

POSIX Mutexes

• POSIX mutexes are of type pthread_mutex_t.

• Features include:

  • Optional recursive lock detection
  • A try lock operation that returns immediately whether or not the mutex can be locked

• It's an error to unlock a POSIX mutex on a thread different from the one that locked it

Mutex Initialization

• POSIX mutexes have static and dynamic initializers:

  • Static: pthread_mutex_t fastmutex = PTHREAD_MUTEX_INITIALIZER;
  • Dynamic: int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);

• Older POSIX versions only allow static initializers for compile-time use.

• The dynamic initializer accepts attributes to configure the mutex; NULL implies default behavior

Mutex Operations

• The functions pthread_mutex_lock, pthread_mutex_trylock, and pthread_mutex_unlock operate as expected

• pthread_mutex_trylock() immediately returns whether a lock could be successfully obtained

• Returns EBUSY if already locked

• Returns 0 if unlocked, locking it and returning

Destroying Mutexes

• Destroy mutexes when no longer needed
• On Linux, destroying a mutex is a no-op (has no effect).
• Destroying a locked mutex is an error
• Destroying a mutex being waited upon is an error

Default Mutex Behaviors

• Default mutexes may not support recursive locking
• Example code demonstrating potential deadlock on Linux

Condition Variables

• Condition variables work with mutexes.

• A thread needs a mutex to wait on a condition variable

• Waiting on a condition variable atomically unlocks the mutex and puts the thread to sleep until signaled

• A thread can signal one or all threads sleeping on a condition variable.

Creating a Condition Variable

• Condition variables are created like mutexes:
  • pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
  • int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);
• Linux Pthread implementation does not support condition variable attributes

Waiting on Condition Variables

• A thread can wait using pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
• Associating mutexes with conditional variables protects the conditional state
• Spurious wakeups can occur in threads

Signaling Conditional Variables

• Condition variables can signal:

  • One waiting thread
  • All waiting threads

• pthread_cond_signal() signals a single waiting thread.

• pthread_cond_broadcast() signals all waiting threads.

Destroying Condition Variables

• When complete, destroy condition variables.
• On Linux, destroying a condition variable has no side effects.
• Destroying a condition variable with waiting threads is an error.

POSIX Semaphores

• POSIX semaphores can work between threads or processes
• Provide counting semaphore semantics
• Replace the System V semaphores
• sem_init(), sem_wait(), sem_trywait(), sem_post() are the main POSIX functions

POSIX Semaphore Creation

• sem_init() creates a semaphore with pshared (allowing inter-process use), initial value.
• No static initialization for POSIX semaphores
• pshared being true implies semaphore can be used between processes
• It needs to be in shared memory to work properly

POSIX Semaphore Manipulation

• sem_wait(): Decrements semaphore; blocks if it is zero.
• sem_trywait(): Attempts to decrement semaphore without blocking.
• sem_post(): Increments the semaphore.
• The wait operation mirrors Dijkstra's P() operation, while post maps to V()

Summary

• POSIX threads provide a thread abstraction on Unix.
• POSIX provides various synchronization primitives (mutexes, semaphores, condition variables, thread joining)
• CS:APP details semaphores

References

• (List of references, if needed)

This quiz covers the fundamentals of POSIX threads, including their creation, synchronization mechanisms, and compilation requirements. Explore mutexes, semaphores, and the intricacies of linking with pthreads in different systems. Master the essentials to effectively implement threading in Unix environments.