Saurav Karmakar

Chapter 4: Threads Overview Multithreading Models Thread Libraries Threading Issues Operating System Examples Windows XP Threads Linux Threads

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

Threads A thread is a single sequence stream within in a

process.

Processes are used to group resources together and threads are the entities scheduled for execution on the CPU.

Sometimes called lightweight processes.

A thread has or consists of thread id, a program counter (PC), a register set, and a stack space.

Threads are not independent of one other like processes

Single and Multithreaded Processes

Multithreaded Server Architecture

When some similar tasks to be served by a server should it create a process or a thread?

Benefits

Responsiveness

Resource Sharing

Economy

Scalability

Process VsThreads Similarities

Threads share CPU and only one thread active (running) at a time.

Threads within a processes execute sequentially. Thread can create children. If one thread is blocked, another thread can run.

DifferencesThreads are not independent of one another. All threads can access every address in the task . Threads are designed to assist one other. Note that processes

might or might not assist one another because processes may originate from different users.

Concurrent Execution on a Single-core System

Parallel Execution on a Multicore System

Multicore Programming Multicore systems putting pressure on

programmers, challenges include

Dividing activitiesBalanceData splittingData dependencyTesting and debugging

User Threads Thread management done by user-level

threads library Thread switching does not need to call operating

system and to cause interrupt to the kernel. The kernel knows nothing about user-level

threads and manages them as if they were single-threaded processes.

Three primary thread libraries: POSIX Pthreads Win32 threads Java threads

Threads in User Space Each process needs a

thread tableSimilar to a process table, but tracks only:

○ Program Counter○ Stack Pointer○ Registers○ State

Table managed by the run-time system

Kernel Threads Supported by the Kernel

The kernel has a thread table that keeps track of all threads in the system.

Operating Systems kernel provides system call to create and manage threads.

Examples Windows XP/2000 Solaris Linux Tru64 UNIX Mac OS X

Threads in Kernel Space Put the concept of the thread in the kernel

There is no need of a run-time system

The kernel has a thread table Threads make calls to the

kernel for thread creation/termination

Kernel holds each thread’s registers, state, etc...

Hybrid Implementations Trys to get to advantage of

both the designsUser and kernel threads are implemented where they will be more efficient

Disadvantage : Complicated design by far

Advantage-Disadvantage Factors Representaion

Management

Speed and Efficiency

Scheduler Decesion

Overheads

Application

Multithreading Models Describes the relationship between user

threads and kernel threads

Three general types :Many-to-One

One-to-One

Many-to-Many

Many-to-One Many user-level threads mapped to single kernel thread Thread management – in user space Entire process gets blocked if one blocks. Only one thread can use kernel at a time Examples:

Solaris Green ThreadsGNU Portable Threads

One-to-One Each user-level thread maps to a kernel thread Better in concurrency Only drawback is creating one of this kind requires

corresponding kernel thread creation Examples

Windows NT/XP/2000LinuxSolaris 9 and later

Many-to-Many Model Allows many user level threads to be mapped to many (smaller or equal #) kernel threads(# depends on application/machine)

Allows the operating system to create a sufficient number of kernel threads

On a blocking call kernel can schedule another thread

Example :Solaris prior to version 9Windows NT/2000 with the ThreadFiber package

Two-level Model Similar to M:M, except that it

allows a user thread to be bound to kernel thread

ExamplesIRIXHP-UXTru64 UNIXSolaris 8 and earlier

Threads Vs Multiprocesses Advantages :

Context SwitchingSharing

Disadvantages :BlockingSecurity

Thread Libraries Thread library provides programmer

with API for creating and managing threads

Two primary ways of implementingLibrary entirely in user spaceKernel-level library supported by the OS

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

Common in UNIX operating systems (Solaris, Linux, Mac OS X)

Win32 Thread Program

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 classImplementing the Runnable interface

Threading Issues Semantics of fork() and exec() system

calls Thread cancellation of target thread

Asynchronous or deferred Signal handling Thread pools Thread-specific data Scheduler activations

Semantics of fork() and exec() Does fork() duplicate only the calling

thread or all threads?

What about exec() ?

What type of fork() is better ?

Thread Cancellation Terminating a thread before it has finished

The thread to be cancelled 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

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 signals1. Signal is generated by particular event2. Signal is delivered to a process3. Signal is handled (default/user-defined)

Signals received:AsynchronouslySynchronously

Signal Handling Signal handler is of two types

1. Default Signal Handler2. User Defined Signal Handler

Options: 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

UNIX : pthread_kill(pid_t, int signal) Windows : emulated through APCs

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

The # of threads on a pool # of CPUs, memory, concurrent # of request

Sophisticated architectures adjust dynamically.

Thread Specific Data Allows each thread to have its own

copy of data

Useful when you do not have control over the thread creation process (i.e., when using a thread pool)

Scheduler Activations Both M:M and Two-level models require

communication to maintain the appropriate number of kernel threads allocated to the application

Many systems implement an intermediate data structure called Lightweight process(LWP)

Scheduler activations provide upcalls - a communication mechanism from the kernel to the thread library

This communication allows an application to maintain the correct number kernel threads

Lightweight Processes (LWP)

Operating System Examples

Windows XP Threads

Linux Thread

Windows XP Threads Implements the one-to-one mapping, kernel-level

Many-to-one model could be implemented throgh fiber-library

Each thread contains A thread id Register set Separate user and kernel stacks Private data storage area – for runtime and dynamic link libraries

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)

Windows XP Threads

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, depending on if certain flags are set.

A unique kernel structure struct task_struct used for each task.

Linux Threads

End of Lecture 4