1. Chapter 4: Threads

2. Chapter 4: Threads Overview Multithreading Models Threading Issues
Pthreads
Windows XP Threads
Linux Threads
Java Threads

3. Motivation
e.g a web browser might have one thread display images while another thread retrieves data from a network.
A word processor may have a thread displaying graphics, another for reading keystrokes, and third for performing spell check
If the web server run as single-threaded process it would be able to service only one client at a time
A server would create a separate thread that would listen for client requests; when a request was made rather than creating a process , it would create another thread to service the requests

4. Single and Multithreaded Processes

5. Benefits
Responsiveness - multithreading an interactive application may allow a program to continue running even if part of it is blocked or is performing a lengthy operation, thereby increasing the responsiveness to the user. Eg web browser could still allow user interaction in one thread while an image is being loaded in another thread
Resource Sharing - share memory and resources of the process they belong leading to use of same address space
Economy - economy in terms of context switch overhead than process
Utilization of MP Architectures- increases concurrency

6. User Threads Thread management done by user-level threads library
The library provides support for thread creation, scheduling and management with no support from kernel.
Faster to create and manage
Three primary thread libraries:
POSIX Pthreads
Win32 threads
Java threads

7. Kernel Threads Supported by the Kernel Slower to create and manage
Examples
Windows XP/2000
Solaris
Linux
Tru64 UNIX
Mac OS X

8. Multithreading Models
Many-to-One
maps many user-level threads to one kernel level.
Thread mgt is done in user space, so it is efficient
But the entire process will block if a thread makes a blocking system call.
One-to-One
it provides more concurrency than many-to-one by allowing another thread to run when a thread makes a blocking system call
Also allows multiple threads to run in parallel on multiprocessors
Drawback is creation user thread requires creation of kernel thread
Many-to-Many
Multiplexes many user-level threads to a smaller or equal number of kernel threads

9. Many-to-One Many user-level threads mapped to single kernel thread
Examples:
Solaris Green Threads
GNU Portable Threads

10. Many-to-One Model

11. One-to-One Each user-level thread maps to kernel thread Examples
Windows NT/XP/2000
Linux
Solaris 9 and later

12. One-to-one Model

13. 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
Solaris prior to version 9
Windows NT/2000 with the ThreadFiber package

14. Many-to-Many Model

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

16. Semantics of fork() and exec()
Does fork() duplicate only the calling thread or all threads of the same process?
In unix there are two choices . One duplicate all threads in the process and another that duplicates only the thread that invoked the fork()

17. Thread Cancellation Terminating a thread before it has finished
Eg pressing the stop button in browser before the arrival of requisition
A thread that is to be cancelled is often called as target thread
Cancellation has two general approaches:
Asynchronous cancellation one thread terminates the target thread immediately
Deferred cancellation allows the target thread to periodically check if it should be cancelled by using cancellation points [ allows a thread to check if it should be cancelled at a point when it can safely be cancelled]
The difficulty with cancellation is where resources have been allocated to a cancelled thread or if a thread was cancelled while in the middle of updating data it is sharing with other threads

18. Signal Handling
Signals are used in UNIX systems to notify a process that a particular event has occurred eg exception handling
A signal may be received synchronous or asynchronous
Synchronous- illegal memory access, division by zero- the signal should be sent to the generated process
Asynchronous – eg <control><c> the signal may/will be sent to all threads
A signal handler is used to process signals
Signal is generated by particular event
Signal is delivered to a process
Signal is handled
Every signal may be handled by one of two possible handlers
1. A default signal handler
2. A 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

19. Thread Pools
Creating a thread is superior to creating process. But has the following disadvantage
Amount of time required to create thread prior to servicing the request, compounded with the fact that this thread will be discarded once it has completed its work.
If we allow all concurrent requests to be serviced in a new thread, and no bound on creation of threads, then unlimited threads could exhaust system resources, such as CPU time. A solution is to use 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

20. 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)

21. Pthreads
A POSIX standard (IEEE c) 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)

22. 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)

23. 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)

24. Java Threads Java threads are managed by the JVM
Java threads may be created by:
Extending Thread class
Implementing the Runnable interface

25. Java Thread States

26. End of Chapter 4