1. 1 School of Computing Science Simon Fraser University CMPT 300: Operating Systems I Ch 4: Threads Dr. Mohamed Hefeeda

2. 2 Objectives  Thread definitions and relationship to process  Multithreading Models  Threading Issues  Example thread libraries  Pthreads, Win32, Java

3. 3 Thread Definitions  Thread is a basic unit of CPU utilization  A sequence of instructions enclosed in a function which CPU can execute as a unit  Process is a program in execution  A process is composed of one or more threads  Thread is comprised of (from OS perspective)  Program counter  Register set, and  Stack  Threads belonging to same process share  Code section  Data section  OS resources such as open files and signals

4. 4 Single and Multithreaded Processes Shared among threads

5. 5 Why Multithreading?  Responsiveness: one thread for GUI and another for processing  Resource Sharing: similar requests handled by the same code and use same files/resources  Economy: threads are much cheaper to create/delete than processes  Utilization of multiprocessors: single threaded-process can NOT make use of multiple processors  Examples of multithreaded applications?  Web browsers: parallel downloads  Web servers: handle multiple concurrent clients  Word processors: spell check in the background  …. Many others …

6. 6 Multithreading Models  Threads can be created/managed at two levels:  User level threads All data structures are maintained in the user level All thread operations are performed in user mode Kernel knows nothing about user-level threads Provided by user-level libraries  Kernel level threads All data structures are maintained in the kernel space  All thread operations have to be in kernel mode (need system calls to perform them) Provided by the OS (kernel) –Most modern OSs (e.g., XP, Linux, MaC OS X, Solaris) are multithreaded

7. 7 Multithreading Models (cont’d)  In multithreaded kernels (i.e., most current OSs), mapping from user-level threads to kernel-level threads can be:  Many-to-One  One-to-One  Many-to-Many

8. 8 Many-to-One  Many user-level threads mapped to single kernel thread  Thread management (create, delete, schedule, …) is done in user level  Pros  Managing user threads are faster (no system calls, no need to switch to kernel mode)  Cons  One thread blocks, the entire process blocks  Can not use multiprocessors  Examples (Libraries)  Solaris Green Threads  GNU Portable Threads

9. 9 One-to-One  Each user-level thread maps to a kernel thread  Pros  Increased concurrency (can use multiprocessors)  A thread blocks, others can run  Cons  Creating too many kernel threads may degrade performance because they consume OS resources  may put limit on number of threads a user can create  Examples: Windows NT/XP/2000, Linux, Solaris 9 and later

10. 10 Many-to-Many Model  Multiple user threads are mapped to multiple kernel threads  Mapping is NOT fixed, need thread scheduler (in user level)  OS support: a user thread blocks, kernel notifies thread scheduler (upcall) to select another to use the free kernel thread  Pros  Increased Concurrency  Flexible: user may create as many user threads as she wants, and kernel creates only a sufficient number of kernel threads  Cons  Complex to implement  Examples:  Solaris prior to version 9  Windows NT/2000 with the ThreadFiber package

11. 11 Two-level Model  Similar to Many-to-Many, except that it allows a user thread to be bound to kernel thread  Bound thread can be used for critical operations or could be the thread scheduler  Examples  IRIX  HP-UX  Tru64 UNIX  Solaris 8 and earlier

12. 12 Some Threading Issues  Semantics of fork() and exec() system calls  Signal handling  Thread pools

13. 13 Semantics of fork() within threads  A process has multiple threads. One of them calls fork()  Should fork() duplicate only the calling thread or all threads (entire process)?  It depends:  If exec() is called immediately after fork(), no need to duplicate all threads (they will be overwritten anyway)  Else, all threads should be duplicated

14. 14 Signal Handling  Signals are used in UNIX to notify a process that an event has occurred  Sequence: 1.Signal is generated by an event 2.Signal is delivered to a process 3.Signal handler processes the signal (default by OS, or user-defined) nSee example code in the textbook

15. 15 Signal Handling (cont’d)  Should OS deliver a signal to: all threads, one thread, or specific thread of a process?  It depends on the signal type  Synchronous: a thread performed an operation that caused a signal to be generated (division by 0, illegal mem. access) Deliver signal to the thread  Asynchronous: external event generated the signal (ctrl–c ) Deliver signal to all threads belonging to the process

16. 16 Thread Pools  Create a number of threads in a pool where they await work  E.g., web server serving many requests of the same page  Advantages  Usually faster to service a request with an existing thread than create a new one  Limit number of threads in an application to pool size Further requests are queued till a thread is free  important to maintain performance

17. 17 Example Thread Libraries  POSIX Threads (pthreads library)  API specifications, implementation is up to the OS  Common in UNIX systems: Solaris, Linux, Mac OS X  Win 32 Threads  Implementation of the one-to-one model in kernel  Java  Java threads are managed by JVM, which is run on top of an OS  JVM specifies the interface, does NOT dictate the implementation  JVM uses thread services provided by the host OS

18. 18 A Note on Linux Threads  Linux refers to threads and processes as tasks  Thread creation is done through clone() system call  clone() can be parameterized to allow a range of resource sharing possibilities:  No sharing of resources between parent and child, the entire process is duplicated (same as fork())  Sharing of all resources between parent and child Only pointers to shared resources are created for child  Linux does not differentiate between process and thread (both are tasks). Is this good or bad?  Good: simplify scheduling  Bad: complex to correlate threads with their processes

19. 19 Summary  A thread is a basic unit of CPU utilization, a process is composed of one or more threads  Thread has: Program counter, stack, registers  Threads share: code, data, OS resources (open files and signals)  User level threads vs. kernel threads  Several mapping models from user threads to kernel threads  M-to-1, 1-to-1, M-to-M  Thread issues: fork(), signals, thread pools,  Thread libraries: pthreads, Win32, Java