ACSC 271 Operating Systems Threads Objectives Overview

Threads 

ACSC 271 

Operating Systems 

Lecture 7: 

Threads 

• Overview 

• Multithreading Models 

• Thread Libraries 

• Threading Issues 

• Operating System Examples 

• Windows XP Threads 

• Linux Threads 

Slide 1 C.Markides ACSC 271: Operating Systems 09/11/2014 


Objectives 

• To introduce the notion of a thread — a 

fundamental unit of CPU utilization that 

forms the basis of multithreaded computer 

systems 

• To discuss the APIs for the Pthreads, 

Win32, and Java thread libraries 

• To examine issues related to multithreaded 

programming 


Overview 

• A thread or a lightweight process (LWP) is a 

basic unit of CPU utilisation, it comprises a thread 

ID, a program counter, a register set, and a stack. 

• A thread shares the same code section, data 

section, and resources (files, and signals) as other 

threads that belong to the same process. 

• If a process has multiple threads of control, it can 

do more than one task at a a time. 

• A traditional heavyweight process has a single 

thread of control. 

Slide 4 C.Markides ACSC 271: Operating Systems 09/11/2014

Web browser 

In General 

Images 

Text 

Process Control Block (PCB) 

Process ID (PID) 

Parent PID 

… 

• This is an abstract view 

• Windows implementation of PCB is 

split in multiple data structures 

Network data 

Images 

Text 

Spelling 

Request 

Listening 

New Thread 

Reply 


Next Process Block 

List of open files 

Image File Name 

List of Thread 

Control Blocks 

… 

PCB 

Handle Table 

Thread Control Block (TCB) 

Next TCB 

Program Counter 

Registers 


… 

CPU Switch from Thread to Thread 

Multithreaded Server Architecture 

Thread T 1 

Interrupt or system call Thread T 2 

executing 

Save state into TCB 1 

Reload state from TCB 2 

ready or 

waiting 

ready or 

waiting 

Interrupt or system call 

Save state into TCB 2 

executing 

executing 

Reload state from TCB 1 

ready or 

waiting 



Benefits 

• Responsiveness – may allow continued execution 

if part of process is blocked, especially important 

for user interfaces 

• Resource Sharing – threads share resources of 

process, easier than shared memory or message 

passing 

• Economy – cheaper than process creation, thread 

switching lower overhead than context switching 

• Scalability – process can take advantage of 

multiprocessor architectures 


Multicore Programming 

• Multicore or multiprocessor systems putting pressure on 

programmers, challenges include: 

– Dividing activities 

– Balance 

– Data splitting 

– Data dependency 

– Testing and debugging 

• 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 


Parallelism 

Single and Multithreaded 

Processes 

• Types of parallelism 

– Data parallelism – distributes subsets of the same data 

across multiple cores, same operation on each 

– Task parallelism – distributing threads across cores, 

each thread performing unique operation 

• As # of threads grows, so does architectural 

support for threading 

– CPUs have cores as well as hardware threads 

• Consider Oracle SPARC T4 with 8 cores, and 8 hardware 

threads per core 



Thread Execution 

Concurrent Execution – Single Core 

Parallel Execution – Multicore 


User and Kernel Threads 

• Support for threads can be provided at user level 

and at kernel level. 

• Thread management done by user-level threads 

library, for example: 

– POSIX Pthreads. – Win32 threads. 

– Mach C-threads. – Java threads. 

– Solaris threads. 

• And supported by the Kernel, for example: 

– Windows 95/98/NT/2000. – Solaris. 

– Tru64 UNIX. – BeOS. 

– Linux. 


Multithreading Models 

• Many-to-One: Maps any user-level threads to one 

kernel thread. Only one thread can access the 

kernel at a time. No multiprocessor support. 

• One-to-One: Maps each user thread to a kernel 

thread. It provides more concurrency, by allowing 

other threads to run in parallel. It offers 

multiprocessor support. 

• Many-to-Many: Multiplexes many user-level 

threads to a smaller or equal number of kernel 

threads. It does not suffer from scheduling or 

concurrency issues than the other models. 

• Two-level: Variation of M-2-M, but also allows a 

user-level thread to be bound to kernel-level 

thread. 


Many-to-One Model 

Examples: 

Solaris Green Threads 

GNU Portable Threads 


Examples: 

Windows NT/XP/2000 

Linux 

Solaris 9 and later 

One-to-One Model 

Many-to-Many Model 

Examples: 

Solaris prior to version 9 

Windows NT/2000 with 

the ThreadFiber package 



Two-level Model 

IRIX 

HP-UX 

Tru64 UNIX 

Solaris 8 and earlier 


Threading Issues 

• The fork() and exec() system calls are used to create a 

separate and duplicate process. In terms of threads the 

behave according to how they are called. 

• Thread cancellation is the task of terminating a thread 

before it has completed. For example a user pressing the 

Stop button to stop the web page loading. 

• Signal handling: A signal is used in UNIX to notify a 

process that a particular event has occurred. For example 

illegal memory access or division by zero. 

• Thread pools: The idea is to create a number of threads at 

process startup, and place them into a pool, where they sit 

and wait for work. 

• Each thread might need its own copy of certain data in 

some cases. This is called thread-specific data. 


Thread Cancellation 

• Terminating a thread before it has finished 

• Two general approaches: 

– Asynchronous cancellation terminates the 

target thread immediately. 

– Deferred cancellation allows the target thread 

to periodically check if it should be cancelled. 

Signal Handling 

• A signal handler is used to process signals 

– Signal is generated by particular event 

– Signal is delivered to a process Remember: 

Ctrl+C 

– Signal is handled 

Or Ctrl+W 

• Options: 

Or Alt+F4 

– Deliver the signal to the thread to which 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 



Thread Pools 

• The idea of thread pools is to create a number of threads 

at process start-up and place them in a pool where they 

await work. 

• Example: If a server receives a request, it awakens a 

thread from the thread pool, if available and passes the 

request for service. 

• 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 

• Number of threads are based on CPUs, physical memory, 

expected number of clients. 


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. 


Pthreads 

• A Portable Operating System Interface part 

X (POSIX) standard (IEEE 1003.1c) 

Application Programming Interface (API) 

for thread creation and synchronization. 

• API specifies behaviour of the thread 

library, implementation is up to 

development of the library. 

• Common in UNIX operating systems. 

• Windows does not support Pthreads. 


Windows Threads 

• What is a thread? 

– An execution context within a process 

– Unit of scheduling (threads run, processes don’t run) 

– All threads in a process share the same per-process 

address space 

• Services provided so that threads can synchronize access to 

shared resources (critical sections, mutexes, events, semaphores) 

– All threads in the system are scheduled as peers to all 

others, without regard to their “parent” process 

• System calls 

– Primary argument to CreateProcess() 

is image file name (or command line) 

– Primary argument to CreateThread() 

is a function entry point address 



• Windows implements the Windows API – primary API for 

Win 98, Win NT, Win 2000, Win XP, and Win 7 

• Implements the one-to-one mapping, kernel-level 

• Each thread contains 

– A thread id 

– Register set representing state of processor 

– Separate user and kernel stacks for when thread runs in user 

mode or kernel mode 

– Private data storage area used by run-time libraries and dynamic 

link libraries (DLLs) 

• The register set, stacks, and private storage area are 

known as the context of the thread 



• Implements the one-to-one mapping. 

• Each thread contains: 

– A thread id. 

– Register set. 

– Separate user and kernel stacks. 

– Private data storage area. 

• The register set, stacks, and private storage area 

are known as the context of the threads 

• The primary data structures of a thread include: 

– ETHREAD (executive thread block) 

– KTHREAD (kernel thread block) 

– TEB (thread environment block) 



Linux Threads 

• Linux refers to them as tasks rather than 

threads. 

• Thread creation is done through clone() 

system call. 

• clone() allows a child task to share the 

address space of the parent task (process). 



Linux Threads 

Java Threads 

• Java threads are managed by the JVM 

• Java threads may be created by: 

– Extending Thread class. 

– Implementing the Runnable interface.

ACSC 271 Operating Systems Threads Objectives Overview

Create successful ePaper yourself

Delete template?

Save as template?