Upload
frederica-tate
View
245
Download
0
Embed Size (px)
DESCRIPTION
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
Citation preview
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