operating system

CMET 331 Operating Systems

4. Threads

Outline • Overview • Multithreading Models • Threading Issues • Windows XP Threads • Linux Threads

Thread • A thread, sometimes called a lightweight

process (LWP), is a basic unit of CPU utilization; it comprises a thread ID, a program counter, a register set, and a stack. —There may be multiple threads in a single process.

Those threads share: • Code • Data • Other OS resources

Single and Multithreaded Processes

Motivation • A traditional (or heavyweight) process has a

single thread of control. • If the process has multiple threads of control, it

can do more than one task at a time. • Examples

—A web browser might have one thread display images or text while another thread retrieves data from the network

—A word processor may have a thread for displaying graphics, another thread for reading keystrokes from the user, and a third thread for performing spelling and grammar checking in the background.

Why Use Threads Other Than Processes? • In fact, this process-creation method was in

common use before threads became popular. • Process creation is very heavyweight • If the new process will perform the same tasks

as the existing process, why incur all that overhead?

• It is generally more efficient for one process that contains multiple threads to serve the same purpose.

Benefits • Takes less time to create a new thread than a

process • Less time to terminate a thread than a process • Less time to switch between two threads within

the same process • Since threads within the same process share

memory and files, they can communicate with each other without invoking the kernel

Some Features • Suspending a process involves suspending all

threads of the process since all threads share the same address space

• Termination of a process, terminates all threads within the process

User Threads • Thread management done by user-level threads

library

• Three primary thread libraries: — POSIX (Portable Operating System Interface)

Pthreads — Win32 threads — Java threads

Kernel Threads • Supported and managed directly by the

operating system

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

Multithreading Models • Many-to-One

• One-to-One

• Many-to-Many

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

thread —Thread management is done by the thread library in

user space, so it is efficient —The entire process will block if a thread makes a

blocking system call —Only one thread can access the kernel at a time,

multiple threads are unable to run in parallel on multiprocessors

• Examples: —Solaris Green Threads —GNU Portable Threads

Many-to-One Model

One-to-One • Each user-level thread maps to a kernel thread

— It provides more concurrency than the many-to-one model by allowing another thread to run when a thread makes a blocking system call

— Multiple threads are able to run in parallel on multiprocessors — The overhead of creating kernel threads can burden the

performance of an application, most implementations of this model restrict the number of threads supported by the system

• Examples — Windows NT/XP/2000 — Linux — Solaris 9 and later

One-to-one Model

Many-to-Many Model • Allows many user level threads to be mapped to

many kernel threads • Allows the operating system to create a

sufficient 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 a thread performs a blocking system call, the kernel can schedule another thread for execution

• Solaris prior to version 9 • Windows NT/2000 with theThreadFiber package

Many-to-Many Model

Threading Issues • Semantics of fork() and exec() system calls • Thread cancellation • Signal handling • Thread pools • Thread specific data • Scheduler activations

Semantics of fork() and exec() • What happens when a multi-threaded process

calls fork()? —All threads could be duplicated.

OR

—Just the calling thread.

• How exec() works? —If a thread invokes the exec () system call, the

program specified in the parameter to exec () will replace the entire process-including all threads.

Thread Cancellation • Terminating a thread before it has finished • A thread that is to be canceled is often referred

to as the 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 signals

1. Signal is generated by particular event 2. A generated signal is delivered to a process 3. Once delivered, the signal must be handled

• Options for delivering a signal: 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

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

Thread Specific Data • Threads belonging to a process share the data

of the process • However, in some circumstances, each thread

might need its own copy of certain data • 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 • One scheme for communication between the user-

thread library and the kernel is known as scheduler activation

• How it works? — The kernel provides an application with a set of virtual

processors (LWPs), and the application can schedule user threads onto an available virtual processor

— The kernel must inform an application about certain events — This procedure is known as an upcall

• 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

Windows XP Threads • 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)

End of Chapter 4