1. Silberschatz, Galvin and Gagne  2002 5.1 Operating System Concepts Chapter 5: Threads  Overview  Multithreading Models  Threading Issues  Pthreads  Solaris 2 Threads  Windows 2000 Threads  Linux Threads  Java Threads

2. Silberschatz, Galvin and Gagne  2002 5.2 Operating System Concepts Thread definition  A thread, sometimes called LWP (Light Weight Process) is a basic unit of CPU utilization  A traditional (Heavy Weight) process has a single thread  Multithreading applications : web browsers, text editors  Threads Share:  Code  Data  Files  Threads have their own:  Thread ID  Program counter  Register set  Stack

3. Silberschatz, Galvin and Gagne  2002 5.3 Operating System Concepts Single and Multithreaded Processes

4. Silberschatz, Galvin and Gagne  2002 5.4 Operating System Concepts Benefits  Responsiveness: Allow a program to continue running even if part of it is blocked or performing lengthy operations  Resource Sharing: By default, threads share memory resources of the process they belong to.  Economy: Allocating memory and other resources is costly. Threads share resources and are more economical to create, share memory among them and context switch.  Utilization of MP Architectures: Best utilization of Multiprocessors architectures (I.e. Parallel processors run each thread).

5. Silberschatz, Galvin and Gagne  2002 5.5 Operating System Concepts Thread types  Two types of threads:  User threads  Kernel thread  The main difference is in who performs:  Thread creation  Thread scheduling  Thread management OS or User!

6. Silberschatz, Galvin and Gagne  2002 5.6 Operating System Concepts User Threads  Thread management done by user-level threads library  Kernel is unaware of multithreading at the process level since all is handled by the User (typically via user libraries)  Examples of available User libraries for handling threads: - POSIX Pthreads - Mach C-threads - Solaris threads

7. Silberschatz, Galvin and Gagne  2002 5.7 Operating System Concepts Kernel Threads  Supported by the Kernel  Examples (most contemporary OS supports Kernel threads): - Windows 95/98/NT/2000 - Solaris - Tru64 UNIX - BeOS - Linux

8. Silberschatz, Galvin and Gagne  2002 5.8 Operating System Concepts Multithreading Models  Many-to-One  One-to-One  Many-to-Many

9. Silberschatz, Galvin and Gagne  2002 5.9 Operating System Concepts Many-to-One  Many user-level threads mapped to single kernel thread.  Used on systems that do not support kernel threads.  Thread management is done is user space.  Advantage:  Thread management is efficient since all done in User space  Disadvantages:  Entire process will block if a thread makes a blocking system call  No support for parallel processors

10. Silberschatz, Galvin and Gagne  2002 5.10 Operating System Concepts Many-to-One Model

11. Silberschatz, Galvin and Gagne  2002 5.11 Operating System Concepts One-to-One  Each user-level thread maps to kernel thread.  Examples - Windows 95/98/NT/2000 - OS/2  Advantages:  Higher level of concurrency  Supports parallel processors  Disadvantages:  Creating a user thread requires creating the corresponding Kernel thread (much overhead)  Must restrict the number of threads to reduce kernel burdens

12. Silberschatz, Galvin and Gagne  2002 5.12 Operating System Concepts One-to-one Model

13. Silberschatz, Galvin and Gagne  2002 5.13 Operating System Concepts Many-to-Many Model  Hybrid of Many-to-one and One-to-One models  Allows many user level threads to be mapped to many kernel threads.  Allows the operating system to create a sufficient number of kernel threads.  OS that use Many-to-Many Model:  Solaris 2  Windows NT/2000 with the ThreadFiber package  IRIX  HP-UX  Tru64UNIX

14. Silberschatz, Galvin and Gagne  2002 5.14 Operating System Concepts Many-to-Many Model

15. Silberschatz, Galvin and Gagne  2002 5.15 Operating System Concepts Threading Issues  Semantics of fork() and exec() system calls.  Thread cancellation.  Signal handling  Thread pools  Thread specific data

16. Silberschatz, Galvin and Gagne  2002 5.16 Operating System Concepts Thread Issues: Semantics of fork() and exec() system calls.  Question: If one thread in a program calls fork, does the new process duplicate all threads or is the new process single-threaded?  Answer: Two versions of fork is provided by some UNIX versions:  One that duplicates all threads  One that duplicates only the thread that invokes the fork  exec typically works similar to a single process environment. That is: if a thread invokes the exec system call, all threads are also created.

17. Silberschatz, Galvin and Gagne  2002 5.17 Operating System Concepts Thread Issues: Thread cancellation  Thread cancellation is the task of terminating a thread before it has completed.  Example: if multiple threads are concurrently searching through a database and one thread returns result, the remaining threads might be cancelled. Or pressing the stop button on the web browser (often a web page is loaded in a separate thread)  The tread that is to be canalled is referred to as the Target thread.  Two different types of canceling threads:  Asynchronous cancellation: Immediately cancel target thread  Deferred cancellation: target thread periodically checks to see if should be cancelled.

18. Silberschatz, Galvin and Gagne  2002 5.18 Operating System Concepts Thread cancellation: Problems  Difficulty arises when 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 (problems specially sever with Asynchronous cancellation).  Deferred cancellation allows for better clean up upon termination since it has time to update the required fields.  The safe states to terminate threads sometimes referred to as “Cancellation points”

19. Silberschatz, Galvin and Gagne  2002 5.19 Operating System Concepts Thread Issues: Signal handling  Signal is used in UNIX to notify a process that a particular event has occurred. Signal may be received Synchronously or Asynchronously.  Regardless of the type of signal, following will take place:  A signal is generated by the occurrences of an event  A generated signal is delivered to a process  Once delivered, the signal must be handled  Synchronous signals are delivered to the same process that performed the operation causing the signal (Example illegal memory access or div by zero)  Asynchronous signals are typically sent to another process (e.g. when CTRL-C is pressed or Time is expired)

20. Silberschatz, Galvin and Gagne  2002 5.20 Operating System Concepts Thread Issues: Signal handling  Handling signals in single-threaded programs is straightforward, signals are always delivered to a process.  How about handling signals in a multithreaded program, which thread should get it? In general, the following options exit:  Deliver the signal to the tread to which the signal applies (specially true for synchronous signals)  Deliver the signal to every thread in the process  Deliver the signal to certain thread in the process  Assign a specific thread to receive all signals for the process. (Solaris 2 implements this option)  Windows uses Asynchronous Procedure Calls (APCs). The APC facility allows a user thread to specify a function that is to be called when user thread receives an event.

21. Silberschatz, Galvin and Gagne  2002 5.21 Operating System Concepts Thread issues: Thread pools  Unlimited threads could exhaust system resources, such as CPU time or memory. Consider creating a treat for every action while browsing the web!  Thread pools: Create a number of threads at process start up and place them into a pool, where they sit and wait for work.  When server receives a request, it awakens a thread from this pool, if one available, and passes it the request.  Once thread competes its service, it returns to the pool awaiting for more work. If pool contains no available thread, waits for a free one.  Benefits of thread pooling:  Faster to service a request with existing thread than waiting to create one  A thread pool limits the number OS threads that exist at any one point.

22. Silberschatz, Galvin and Gagne  2002 5.22 Operating System Concepts Thread issues: Thread-specific Data  Threads belonging to a process share the data of the process. (a great benefit of multithreading)  However, each thread might need its own copy of certain data in some circumstances (I.e. thread-specific data)  Most thread libraries (e.g. Win32 and Pthreads) provide some form of support for thread-specific data. Java provides support as well.

23. Silberschatz, Galvin and Gagne  2002 5.23 Operating System Concepts Optional reading  The following sections of the text (and corresponding slides) are specific to certain Operating Systems and are NOT Required reading for the course:  Section 5.4  Pthreads  Section 5.5  Solaris 2 Threads  Section 5.6  Windows 200 Threads  Section 5.7  Linux Threads  Section 5.8  Java Threads

24. Silberschatz, Galvin and Gagne  2002 5.24 Operating System Concepts Pthreads  a POSIX standard (IEEE 1003.1c) API for thread creation and synchronization.  API specifies behavior of the thread library, implementation is up to developer of the library.  Common in UNIX operating systems.

25. Silberschatz, Galvin and Gagne  2002 5.25 Operating System Concepts Pthread Example #include Main () { pthread_id tid; pthread_att attr; /* perform whaterver code you are designed to do */ pthread_attr_init(&attr); /* get thread attributes, e.g. stack size, scheduling info */ pthread_create(&tid, &attr, RunFunc, parm1, parm2); /* create a new thread /* perform other tasks */ pthread_join(tid, NULL); /* now wait for the thread to exist */ } RunFunc(Parm1, Parm 2) { /* do whatever you intended to do */ pthread_exit(0); }

26. Silberschatz, Galvin and Gagne  2002 5.26 Operating System Concepts Solaris 2 Threads

27. Silberschatz, Galvin and Gagne  2002 5.27 Operating System Concepts Solaris Process

28. Silberschatz, Galvin and Gagne  2002 5.28 Operating System Concepts Windows 2000 Threads  Implements the one-to-one mapping.  Each thread contains - a thread id - register set - separate user and kernel stacks - private data storage area

29. Silberschatz, Galvin and Gagne  2002 5.29 Operating System Concepts 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)

30. Silberschatz, Galvin and Gagne  2002 5.30 Operating System Concepts Java Threads  Java threads may be created by:  Extending Thread class  Implementing the Runnable interface  Java threads are managed by the JVM.

31. Silberschatz, Galvin and Gagne  2002 5.31 Operating System Concepts Java Thread States