1

CHAPTER 5: THREADS AND

CONCURRENCY
OPERATING SYSTEMS (CS-2006)
SPRING 2022, FAST NUCES

[email protected] Course Supervisor: ANAUM HAMID

Motivation
� Most modern applications are multithreaded
� Threads run within application
� Multiple tasks with the application can be implemented by separate
threads
◦ Update display
◦ Fetch data
◦ Spell checking
◦ Answer a network request
� Process creation is heavy-weight while thread creation is light-weight
� Can simplify code, increase efficiency
� Kernels are generally multithreaded
 Control Blocks
• Information associated with each process: Process Control Block

1. Memory management information

2. Accounting information

• Information associated with each thread: Thread Control Block

1. Program counter

2. CPU registers

3. CPU scheduling information

4. Pending I/O information

3
Course Supervisor: ANAUM HAMID
 Control Blocks
Process ID (PID)
Parent PID
…

Next Process Block PCB

List of open files Handle Table

Image File Name

Thread Control Block (TCB)
List of Thread
Control Blocks Next TCB
Program Counter
… Registers

0
Course Supervisor: ANAUM HAMID
 Single & Multithreading
Process
• Each thread has

• An execution state (Running, Ready, etc.)

• Saved thread context when not running

• An execution stack

• Some per-thread static storage for local variables

• Access to the memory and resources of its

process (all threads of a process share
this)

• Suspending a process involves

suspending all threads of the process

• Termination of a process terminates all

threads within the process

6
Course Supervisor: ANAUM HAMID
Threads
Threads specific
Threads share…. Attributes….
� Global memory ● Thread ID

� Process ID and parent ● Thread specific data

process ID ● CPU affinity
● Stack (local variables and function
� Controlling terminal
call linkage information)
� Process credentials (user ) ● ……
� Open file information
� Timers
� ………

Course Supervisor: ANAUM HAMID

Single and Multithreaded
Processes
Process
Vs.
Threads

Course Supervisor: ANAUM HAMID

Multithreaded Server
Architecture
10

� Responsiveness – One thread may provide rapid

response while other threads are blocked or slowed down
Benefits doing intensive calculations.

� Resource Sharing – By default threads share common

code, data, and other resources, which allows multiple
tasks to be performed simultaneously in a single address
space.

� Economy – Creating and managing threads ( and

context switches between them ) is much faster than
performing the same tasks for processes.

� Scalability – Utilization of multiprocessor architectures

- A single threaded process can only run on one CPU, no
matter how many may be available, whereas the
execution of a multi-threaded application may be split
amongst available processors.

Course Supervisor: ANAUM HAMID

Multicore Programming
� A recent trend in computer architecture is to
produce chips with multiple cores, or CPUs on a
single chip.
� Parallelism implies a system can perform more
than one task simultaneously
� Concurrency supports more than one task making
progress
◦ Single processor / core, scheduler providing concurrency

Course Supervisor: ANAUM HAMID 11

Concurrency vs. Parallelism
• Concurrent execution on single-core
system:

• Parallelism on a multi-core system:

Course Supervisor: ANAUM HAMID 12

Thread
Dispatchin
g Thread T1
Interrupt or system call Thread T2

executing
Save state into TCB1 ready or
waiting
Reload state from TCB2

Interrupt or system call

ready or executing
waiting
Save state into TCB2

Reload state from TCB1

ready or
waiting
executing

Course Supervisor: ANAUM HAMID

 14
Types of Parallelism

Course Supervisor: ANAUM HAMID

 Data Parallelism Task Parallelism
Course Supervisor: ANAUM HAMID
Same operations are performed Different operations are
15 on different subsets of same performed on the same or
data. different data.

Data vs. Synchronous computation Asynchronous computation

Task Speedup is less as each

processor will execute a

Parallelism
Speedup is more as there is different thread or process on
only one execution thread the same or different set of
operating on all sets of data. data.

Amount of parallelization is Amount of parallelization is

proportional to the input data proportional to the number of
size. independent tasks to be
performed

Designed for optimum load Load balancing depends on the

balance on multi processor availability of the hardware and
system. scheduling algorithms like static
and dynamic scheduling.

Course Supervisor: ANAUM HAMID

 Amdahl’s Law
� gives the theoretical speedup in latency of the execution of a
task at fixed workload that can be expected of a system
whose resources are improved

Where S = portion of program executed serially

N = Processing Cores

Course Supervisor: ANAUM HAMID

 Amdahl’s Law Example
� we have an application that is 75 percent parallel and 25
percent serial. If we run this application on a system with two
processing
cores?
� S=25%=0.25, N= 2

� If we add two additional cores , calculate speedup?

Course Supervisor: ANAUM HAMID

 Types of Threads
● Support provided at either

● User level -> user threads

Supported above the kernel and managed without kernel support

● Kernel level -> kernel threads

Supported and managed directly by the operating system

What is the relationship between user and kernel threads?

Course Supervisor: ANAUM HAMID

User and Kernel Threads
 User Threads
� Thread management done by user-level threads library

� Three primary thread libraries:

◦ POSIX Pthreads
◦ Win32 threads
◦ Java threads

Course Supervisor: ANAUM HAMID

Kernel Threads
� Supported by the Kernel

� Examples
◦ Windows
◦ Linux
◦ Mac OS X
◦ iOS
◦ Android

Course Supervisor: ANAUM HAMID

Multithreading models
In a specific implementation, the user threads must be mapped
to kernel threads, using these listed below Multithreading
Models:
1. Many-to-One

2. One-to-One

3. Many-to-Many User Thread – to - Kernel Thread

Course Supervisor: ANAUM HAMID 22

 Many-to-One
Many user-level threads
mapped to single kernel thread

� Only one thread can access

the kernel at a time,

� multiple threads are unable

to run in parallel on
multicore systems.

� the entire process will block if a

thread makes a blocking system
call

Course Supervisor: ANAUM HAMID 23

 One-to-One
Each user-level thread maps to kernel thread
� more concurrency than the many-to-one model by allowing another thread to run when
a thread makes a blocking system call.
� Allows multiple threads to run in parallel on multiprocessors.

� drawback is, creating a user thread requires creating the corresponding kernel thread

Course Supervisor: ANAUM HAMID 24

Many-to-Many Model
� multiplexes many user-level
threads to a smaller or equal
number of kernel threads

� developers can create as many

user threads as necessary, and
the corresponding

� kernel threads can run in parallel

on a multiprocessor.

� When thread performs a blocking

system call, the kernel can
schedule another thread for
execution.

Course Supervisor: ANAUM HAMID 25

 Thread Libraries
� Three main thread libraries in use today:
◦ POSIX Pthreads
● May be provided either as user-level or kernel-level
● A POSIX standard (IEEE 1003.1c) API for thread creation and synchronization
● API specifies behavior of the thread library, implementation is up to development of the
library
◦ Win32
● Kernel-level library on Windows system
◦ Java
● Java threads are managed by the JVM
● Typically implemented using the threads model provided by underlying OS

Course Supervisor: ANAUM HAMID

Pthreads Example
Pthreads Example (Cont.)
Pthreads Code for Joining 10 Threads
Windows Multithreaded C
Program
Windows Multithreaded C Program (Cont.)
Java Threads
� Java threads are managed by the JVM
� Typically implemented using the threads model
provided by underlying OS
� Java threads may be created by:
◦ Extending Thread class
◦ Implementing the Runnable interface

◦ Standard practice is to implement Runnable interface

Java Threads
Implementing Runnable interface:

Creating a thread:

Waiting on a thread:
Implicit Threading
� Creation and management of threads done by
compilers and run-time libraries rather than
programmers
� These listed below methods explored
1. Thread Pools
2. Fork Join
3. OpenMP
4. Grand Central Dispatch.
5. Intel Threading Building Blocks

Course Supervisor: ANAUM HAMID 34

Thread Pools
� Create a number of threads in a pool
where they await work
� Advantages:
◦ Usually slightly faster to service a request with
an existing thread than create a new thread
◦ Allows the number of threads in the
application(s) to be bound to the size of the
pool
Fork-Join Parallelism
� Multiple threads (tasks) are forked, and then joined.

Course Supervisor: ANAUM HAMID 36

 OpenMP
• An Application Program Interface (API) that may be used to
explicitly direct multithreaded, shared memory parallelism

• Three main API components

– Compiler directives
– Runtime library routines
– Environment variables

• Portable & Standardized

– API exist both C/C++ and Fortan 90/77
– Multi platform Support (Unix, Linux etc.)

Course Supervisor: ANAUM HAMID

 Open MP Example

Course Supervisor: ANAUM HAMID

 Threading Issues

1. Semantics of fork() and exec() system calls

2. Signal handling
3. Thread cancellation of target thread
4. Thread-local storage
5. Scheduler Activations
Semantics of fork() and exec()

� Does fork()duplicate only the calling thread

or all threads?
◦ Some UNIXes have two versions of fork
� exec() usually works as normal – replace the
running process including all threads
 Thread Cancellation
� Terminating a thread before it has finished
� Thread to be canceled is target thread

� Two general approaches:

◦ Asynchronous cancellation terminates the target thread immediately
◦ Deferred cancellation allows the target thread to periodically check if it
should be cancelled
◦ Cancellation only occurs when thread reaches cancellation point
● i.e., pthread_testcancel()
● Then cleanup handler is invoked
Pthread code to create and cancel a thread

Course Supervisor: ANAUM HAMID 42

 Thread-Local Storage

� Thread-local storage (TLS) allows

each thread to have its own copy of
data.
� major thread libraries ( pThreads, Win32,
Java ) provide support for thread-specific
data, known as thread-local
storage or TLS.

Course Supervisor: ANAUM HAMID Course Supervisor: ANAUM HAMID 43

 Signal Handling
� Signals are used in UNIX systems to notify a process that a particular event has occurred.
� A signal handler is used to process signals
1. Signal is generated by particular event
2. Signal is delivered to a process
3. Signal is handled by one of two signal handlers:
1. default
2. user-defined
� Where should a signal be delivered for multi-threaded?
1. Deliver the signal to the thread to which the signal applies
2. Deliver the signal to every thread in the process
3. Deliver the signal to certain threads in the process
4. Assign a specific thread to receive all signals for the process

Course Supervisor: ANAUM HAMID 44

 Scheduler Activations
� Both M:M and Two-level models require
communication to maintain the appropriate number
of kernel threads allocated to the application
� Typically use an intermediate data structure between
user and kernel threads – lightweight process (LWP)
◦ Appears to be a virtual processor on which process can schedule
user thread to run
◦ Each LWP attached to kernel thread
◦ How many LWPs to create?
� Scheduler activations provide upcalls - a
communication mechanism from the kernel to the
upcall handler in the thread library
� This communication allows an application to maintain
the correct number kernel threads
 Kernel Scheduling

Course Supervisor: ANAUM HAMID

THANK YOU

Course Supervisor: ANAUM HAMID 47