1. 1 Lecture 4: Threads Operating System Fall 2006

2. 2 Contents Overview: Processes & Threads Benefits of Threads Thread State and Operations User Thread and Kernel Thread Multithreading Models Threading Issues

3. 3 Process Resource ownership process is allocated a virtual address space to hold the process image Process may be allocated control or ownership of resources, e.g. I/O and files Protection function by OS Scheduling/execution The execution of a process follows an execution path(trace) through one or more programs The execution of a process may be interleaved with other processes Execution state and a dispatching priority These two characteristics are treated independently by the operating system

4. 4 Processes & Threads Resource ownership – Process or Task Scheduling/execution – Thread or lightweight process One process, one thread (MS-DOS) One process, multiple threads (Java Runtime) Multiple processes, multiple threads (W2K, Solaris, Linux) Multiple processes, one thread per process (Unix)

5. 5 Processes & Threads (cont.) In a multithreaded environment, the followings are associated with a process: Address space to hold the process image Protected access to processors, other processes (IPC), files, and I/O resources (devices & channels) Within a process, there may be one or more threads, each with the following: A thread execution state (Running, Ready, etc) A saved context when not running – a separate program counter An execution stack Some static storage for local variables for this thread Access to memory and resources of its process, shared with all other threads in that process (global variables)

6. 6 Single Threaded and Multithreaded Process Models

7. 7 Benefits of Threads 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 responsiveness to the use. Resource Sharing Since threads within the same process share memory and files, they can communicate with each other without invoking the kernel

8. 8 Benefits of Threads (cont.) Economy 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 Utilization of Multiprocessor Architectures Threads within the same process may be running in parallel on different processors

9. 9 Uses of Threads in a Single- User Multiprocessing System Foreground and background work For example, in a spreadsheet program, one thread could display menus and read user input, while another thread executes user commands and updates the spreadsheet. Asynchronous processing Asynchronous elements in the program can be implemented as threads. For example, as a protection against power failure, a word processor may write its buffer to disk once every minute. A thread can be created whose sole job is periodic backup and that schedules directly with the OS. Speed execution On a multiprocessor system, multiple threads from the same process may be able to execute simultaneously. Modular program structure Programs that involve a variety of activities or a variety of sources and destinations of input and output may be easier to design and implement using threads.

10. 10 Thread States Running Ready Blocked Note: Suspend is at process-level

11. 11 Thread Operations Spawn – create new thread Block – when a thread needs to wait for an event, it will block Unblock – when the event for which a thread is blocked occurs, the thread is moved to the ready queue. Finish – when a thread completes, its register context and stack are deallocated.

12. 12 Threads 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

13. 13 Question? If one thread in a process is blocked, does this prevent other threads in the process even if that other thread is in a ready state?

14. 14 Answer Depends on whether OS is involved when the thread is blocked. If OS is involved, then answer is “yes”.

15. 15 Thread Synchronization All of the threads of a process share the same address space and other resources such as open files. Any alternation of a resource by one thread affects the environment of the other threads in the same process. It is therefore necessary to synchronize the activities of the various threads. Will be covered later.

16. 16 User Thread and Kernel Thread

17. 17 User Threads All of the work of thread management is done by the application. The kernel is not aware of the existence of threads An application can be programmed to be multi-threaded by using a threads library, which is a package of routines for user thread management. The thread library contains code for creating and destroying threads, for passing messages and data between threads, for scheduling thread execution and for saving and restoring thread contexts. Three primary thread libraries: POSIX Pthreads Win32 threads Java threads

18. 18 Pure User Threads Advantages: Thread switching does not require user/kernel mode switching. Thread scheduling can be application specific. User Threads can run on any OS through a thread library. Disadvantages: When a ULT executes a system call, not only the thread is blocked, but all of the threads within the process are blocked. Multithreaded application cannot take advantage of multiprocessing since kernel assign one process to only one processor at a time.

19. 19 Kernel Threads Supported and managed directly by the OS. W2K, Linux, and OS/2 are examples of this approach In a pure Kernel Thread facility, all of the work of thread management is done by the kernel. There is no thread management code in the application area, simply an application programming interface to the kernel thread facility.

20. 20 Pure Kernel Threads Advantages Kernel can simultaneously schedule multiple threads from the same process on multiple processors If one thread in a process is blocked, kernel can schedule another thread of the same process Disadvantage More overhead

21. 21 Multithreading Models Many-to-One One-to-One Many-to-Many

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

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

24. 24 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

25. 25 Two-level Model Similar to M:M, except that it allows a user thread to be bound to kernel thread Examples IRIX HP-UX Tru64 UNIX Solaris 8 and earlier

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

27. 27 Semantics of fork() and exec() Does fork() duplicate only the calling thread or all threads?

28. 28 Thread Cancellation Terminating a thread before it has finished Two general approaches: Asynchronous cancellation terminates the target thread immediately Deferred cancellation allows the target thread to periodically check if it should be cancelled

29. 29 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. Signal is delivered to a process 3. Signal is handled 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

30. 30 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

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

32. 32 Scheduler Activations Both M:M and Two-level models require communication to maintain the appropriate number of kernel threads allocated to the application 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

33. 33 End of lecture 4 Thank you!