Chapter 4: Threads

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

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

Single and Multithreaded Processes

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

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

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

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

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

Many-to-One Model

One-to-One Each user-level thread maps to kernel thread 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 Solaris prior to version 9 Windows NT/2000 with the ThreadFiber 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() 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()

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

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

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

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)

Pthreads 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)

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)

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

Java Thread States

End of Chapter 4