Overview

These are also known as lightweight processes.

Threads differ from Processes in that they share the user processes' address space. They have their own stack pointer and stack, program counter, and registers but can access the memory of parent processes and even that of other threads.

Benefits

• Responsiveness - Threads can swap execution to improve efficiency
• Resource Sharing - Using shared memory to access data across threads
• Economy - Using shared memory is more efficient time and memory space wise.
• Scalability - Multicore CPU utilization

Shared Data

• Process instructions (text region of memory)
• Open files (descriptors)
• Signals and signal handlers
• Current working directory
• User and group id

Thread Specific Data

• Thread id
• Registers
• Stack pointer/stack
• Signal mask - (can handle signals for the entire process hiding it from other threads)
• Scheduling properties
• Return value

Thread Types

User Level Threads

User level threads operate on the principle that the underlying OS does not support threading.

Advantages

• Efficient space usage and higher speed
• Low cost of switching
• Low cost of scheduling
• OS independent

Disadvantages

• One thread blocked on I/O blocks all threads ^[1]
• Difficult to take advantage of SMP (symmetrical multiprocessing)

Kernel Level Threads

Advantages

• Removes disadvantages of #User Level Threads
• Threads can be treated as individually schedulable

Disadvantages

• Greater overhead due to kernel level threads.

Relationships Between Thread Types

Since many OSes support threads nowadays there are multiple models for allocating #Kernel Level Threads to #User Level Threads.

Many-to-One

This maps many user level threads to one kernel level threads.

One-to-One

This maps many user level threads to many kernel level threads.

It allows for blocked threads not to interfere with other threads as each thread is treated as a schedulable entity by the OS.

Many-to-Many

Also notated as M:M

This maps $m$ user level threads to $n$ kernel level threads.

It allows for less OS overhead when trying to create threads, while still providing the benefits of the #One-to-One model.

Two-Level

This is mostly the same as #Many-to-Many with the added functionality of control over how user threads are mapped to kernel threads.

Thread Cancellation

Asynchronous Cancellation

Asynchronous cancellation has the process immediately terminates the target thread. This comes with a few caveats:

• Allocated resources may not be freed easily
• Status of shared data may remain ill-defined

Deferred Cancellation

Deferred cancellation is where a thread terminates itself. This way orderly cancellation can be easily achieved. However, failure to check cancellation status may cause issues.

Signal Handling

Signal handling can be done by threads. There are two basic types of signals:

• Synchronous: Generated by some event in the process
• Asynchronous: Generated by some event outside the process

In Unix-like systems you can apply a signal mask to threads to have them handle signals sent to the process they belong to. There are a few different ways to handle these signals.

• Delivering the signal to the thread where the signal applies

• Deliver the signal to every thread in the process

• Deliver the signal to certain threads in the process

• Assign a specific thread to receive all signals for the process

Implicit Threading

Writing multi-threaded programs are difficult to do correctly. It can cause latency and performance issues if done incorrectly.

The solution is to use compiler directives and runtime libraries to help manage threads (semi) automatically.

Thread Pools

This is a runtime library that manages the use of multiple user threads and how they are mapped to kernel threads.

Thread pools create a number of kernel threads up to the number of logical processors in a system. When a new thread is created by the user they are added to the pool where they await assignment to a kernel thread (work).

• Faster to service a request as you don't have to keep creating/destroying kernel threads
• Allows number of threads to be bound to the size of the pool

OpenMP

This is a compiler directive that is included with GCC. It supports parallel programming in shared-memory environments.

OpenMP manages shared memory for the user. Although users can identify a parallel region and try to access or modify it, OpenMP will not allow the operation to occur if it knows the region is shared.

Programming

Threads can be created using the pthreads API. This is a POSIX standard library.

Example:

#include <pthread.h>

void *runner (void *param); // pointer to function for the thread to run

int main(int argc, char *argv[]) {
  pthread_t tid;
  pthread_attr_t attrs;

  // Default attributes for the thread
  pthread_attr_init(&attr);
  // Start running the thread
  pthread_create(&tid, &attr, runner, argv[1]);
  // Wait for the thread to finish
  pthread_join(tid, NULL);
}

Linux refers to threads as tasks. To create a task we can create a #Kernel Level Threads with the clone() syscall.

System Call Semantics

fork()

Some system provide two different versions of fork() but Linux duplicates only the thread called by fork(). That is the resulting child process will only have one thread.

exec()

In Linux calling exec() from any thread will wipe the entire process image, therefore overwriting all threads.

Unix Thread Cancellation

Reference

1. Kulkarni, Prasad Various Lectures The University of Kansas 2024

Related

• Processes
• UNIX Linux