Module 5 Threads 92903 Overview Benefits User and

Module 5: Threads 9/29/03+ • • • Overview Benefits User and Kernel Threads Multithreading Models Solaris 2 Threads Java Threads NOTE: Instructor annotations in BLUE Applied Operating System Concepts 5. 1 Silberschatz, Galvin, and Gagne 1999

Threads - Overview • A thread (or lightweight process) is a basic unit of CPU utilization; it consists of: – program counter – register set – stack space • A thread shares with its peer threads (in same process) its: – code section – data section – operating-system resources collectively know as a task. Actually the three things above belong to the process Threads in the process share this stuff. • A traditional or heavyweight process is equal to a task with one thread Applied Operating System Concepts 5. 2 Silberschatz, Galvin, and Gagne 1999

Threads (- Overview Cont. ) • In a multiple threaded task, while one server thread is blocked and waiting, a second thread in the same task can run. (assuming the blocked thread doesn’t block the process - if so, everything comes to a screeching halt!) – Cooperation of multiple threads in same job confers higher throughput and improved performance. – Applications that require sharing a common buffer (i. e. , producer-consumer) benefit from thread utilization. • Threads provide a mechanism that allows sequential processes to make blocking system calls while also achieving parallelism. … a thread within the process makes the call & only it blocks while other threads in the process still run …assuming kernel supported threads • Kernel-supported threads – can reside in user or kernel space, but kernel is involved in their control. • User-level (supported) threads; supported from a set of library calls at the user level. Resides in user space. • Hybrid approach implements both user-level and kernel-supported threads (Solaris 2). Applied Operating System Concepts 5. 3 Silberschatz, Galvin, and Gagne 1999

Multiple Threads within a Task Applied Operating System Concepts 5. 4 Silberschatz, Galvin, and Gagne 1999

Benefits • Responsiveness - Opens the possibility of blocking only one thread in a process on a blocking call rather than the entire process. • Resource Sharing – Threads share resources of process to which they belong – code sharing allow multiple instantiations of code execution • Economy – low overhead in thread context switching & thread management compared to process context switching & management • Utilization of MP Architectures – can be applied to a multiprocessor. In a uniprocessor, task switching is so fast that it gives illusion of parallelism. Applied Operating System Concepts 5. 5 Silberschatz, Galvin, and Gagne 1999

Single and Multithreaded Processes Applied Operating System Concepts 5. 6 Silberschatz, Galvin, and Gagne 1999

User Level (supported) Threads (ULTs) • • Thread Management Done by User-Level Threads Library • If thread blocks, the kernel sees it as the process blocking, and may block the entire process (all threads). • Examples Kernel unaware of ULTs No kernel intervention needed for thread management. Thus fast to create and manage - POSIX Pthreads - Mach C-threads - Solaris threads … but not totally kernel independent … Applied Operating System Concepts 5. 7 Silberschatz, Galvin, and Gagne 1999

Kernel Level (supported) Threads (KLTs) • Supported by the Kernel – thread management done by kernel in kernel space. • Since kernel managing threads, kernel can schedule another thread if a given thread blocks rather than blocking the entire processes. • Examples - Windows 95/98/NT - Solaris - Digital UNIX Applied Operating System Concepts 5. 8 Silberschatz, Galvin, and Gagne 1999

Multithreading Models User Threads / Kernel Threads models. Three common types of threading implementation: • Many-to-One • One-to-One • Many-to-Many Applied Operating System Concepts 5. 9 Silberschatz, Galvin, and Gagne 1999

Many-to-One • • • Many User-Level Threads Mapped to Single Kernel Thread. • Bad for multiprocessor (parallel) architectures because only one thread at a time can access kernel. • Used on Systems That Do Not Support Kernel Threads. - Single threaded kernel Thread management done at user level - efficient Entire user processes blocks if one of its threads block – kernel only sees the process. Applied Operating System Concepts 5. 10 Silberschatz, Galvin, and Gagne 1999

Many-to-one Model Applied Operating System Concepts 5. 11 Silberschatz, Galvin, and Gagne 1999

One-to-One • • Each User-Level Thread Maps to a distinct Kernel Thread. • Multiple threads can run in parallel in a multiprocessing architecture. • Drawback is that creating a user thread requires creating a kernel thread … overhead factor … number of threads restricted • Examples Other threads can run when a particular thread makes a blocking call - better concurrency. - Windows 95/98/NT - OS/2 Applied Operating System Concepts 5. 12 Silberschatz, Galvin, and Gagne 1999

One-to-one Model Applied Operating System Concepts 5. 13 Silberschatz, Galvin, and Gagne 1999

Many-to-Many Model • Time Multiplexes many ULT’s to a smaller of equal number of KLT’s. • Number of kernel threads may be specific to either a particular application or machine … typically a multiprocessor may get more k-threads than a uniprocessor. • Programmer may create as many user threads as desired (compare to 1 -to-1 in which there my be a shortage of k-threads. • True concurrency limited to scheduling (multiplexing) many user threads against a less number of k-threads. But the multiple kthreads can be run in parallel on a multiprocessor machine. Applied Operating System Concepts 5. 14 Silberschatz, Galvin, and Gagne 1999

Many-to-many Model Applied Operating System Concepts 5. 15 Silberschatz, Galvin, and Gagne 1999

Pthreads • • Example of user controlled threads • More commonly implemented on UNIX based system such as Solaris • Runs from a Pthead user level library with not specified relationship and any associated kernel threads. – Some implementations may allow some kernel control ex: scheduling? ? ? • The “main” function in the C application program is the initial thread created by default, all other threads are created using library calls from the application program- each thread has stack Refers to the POSIX standard (IEEE 1003. 1 c) API - specifies behavior, not implementation. Applied Operating System Concepts 5. 16 Silberschatz, Galvin, and Gagne 1999

Pthreads (continued) • Two typical Pthread library calls: – pthread_create T creates a new thread T allows you to pass the name of a function which has will be the behavior or function that this thread will do. T Allows you to pass parameters to the function of the new thread. T sets a thread id variable to the unique “tid”. – Pthread_join T allows a thread to wait for another specified thread to complete before continuing on - a synchronization tedchique • There is a very large and rich set of library function calls to use in Pthread programming - Lots of calls for thread synchronization more later! • See example in Figure 5. 5, page 140. Applied Operating System Concepts 5. 17 Silberschatz, Galvin, and Gagne 1999

Threads Support in Solaris 2 • Solaris 2 is a version of UNIX with support for threads at both the kernel and user levels, symmetric multiprocessing, and real-time scheduling. • Solaris 2 implements the pthread API, in addition to supporting userlevel threadswith a thread library with API’s for thread creation & management ==> Solaris threads • • LWP – intermediate level between user-level threads and kernel-level threads. Resource needs of thread types: – Kernel thread (are in the kernel - does OS stuff or associates with an LWP) : small data structure and a stack; thread switching does not require changing memory access information – relatively fast. – LWP: Associated with a both a user process (PCB) and a kernel thread. Has register data, accounting, and memory information; switching between LWPs is relatively slow. - because of kernel intervention. Scheduled by kernel – User-level thread: only need stack and program counter; no kernel involvement means fast switching (multiplexing to LPW). Kernel only sees the LWPs that are dedicated to user-level threads. Applied Operating System Concepts 5. 18 Silberschatz, Galvin, and Gagne 1999

Solaris 2 Threads Applied Operating System Concepts 5. 19 Silberschatz, Galvin, and Gagne 1999

Solaris Threads • Threads in user space similar to “pure” Pthreads but with required kernel control • Process Structure control information completely in kernel space • LWP in kernel space but share the user process resources can interface with user threads - is visible to user threads. • LWP can be thought of as a virtual CPU that is available for executing code. . . We have a single process in one memory space with many virtual “CPU’s” running different parts of the process concurrently (Lewis & Berg). • Each LWP is separately scheduled by kernel - kernel schedules LWP’s not user threads. • The thread library for user threads is in user space - the user level thread library schedules (multiplexes) user threads onto LWP’s, and LWP’s, in turn, are implemented by kernel threads and scheduled by the kernel. Applied Operating System Concepts 5. 20 Silberschatz, Galvin, and Gagne 1999

Solaris Process Applied Operating System Concepts 5. 21 Silberschatz, Galvin, and Gagne 1999

Java Threads • Java Threads May be Created by: – Extending Thread class – Implementing the Runnable interface Applied Operating System Concepts 5. 22 Silberschatz, Galvin, and Gagne 1999

Extending the Thread Class class Worker 1 extends Thread { public void run() { System. out. println(“I am a Worker Thread”); } } Applied Operating System Concepts 5. 23 Silberschatz, Galvin, and Gagne 1999

Creating the Thread public class First { public static void main(String args[]) { Worker runner = new Worker 1(); runner. start(); System. out. println(“I am the main thread”); } } Applied Operating System Concepts 5. 24 Silberschatz, Galvin, and Gagne 1999

The Runnable Interface public interface Runnable { public abstract void run(); } Applied Operating System Concepts 5. 25 Silberschatz, Galvin, and Gagne 1999

Implementing the Runnable Interface class Worker 2 implements Runnable { public void run() { System. out. println(“I am a Worker Thread”); } } Applied Operating System Concepts 5. 26 Silberschatz, Galvin, and Gagne 1999

Creating the Thread public class Second { public static void main(String args[]) { Runnable runner = new Worker 2(); Thread thrd = new Thread(runner); thrd. start(); System. out. println(“I am the main thread”); } } Applied Operating System Concepts 5. 27 Silberschatz, Galvin, and Gagne 1999

Java Thread Management • suspend() – suspends execution of the currently running thread. • sleep() – puts the currently running thread to sleep for a specified amount of time. • • resume() – resumes execution of a suspended thread. stop() – stops execution of a thread. Applied Operating System Concepts 5. 28 Silberschatz, Galvin, and Gagne 1999

Java Thread States Runnable state has both actively executing threads, and “ready” threads Applied Operating System Concepts 5. 29 Silberschatz, Galvin, and Gagne 1999

Producer Consumer Problem public class Server { public Server() { Message. Queue mail. Box = new Message. Queue(); Producer producer. Thread = new Producer(mail. Box); Consumer consumer. Thread = new Consumer(mail. Box); producer. Thread. start(); consumer. Thread. start(); } public static void main(String args[]) { Server server = new Server(); } } Applied Operating System Concepts 5. 30 Silberschatz, Galvin, and Gagne 1999

Producer Thread class Producer extends Thread { public Producer(Message. Queue m) { mbox = m; } public void run() { while (true) { // produce an item & enter it into the buffer Date message = new Date(); mbox. send(message); } } private Message. Queue mbox; } Applied Operating System Concepts 5. 31 Silberschatz, Galvin, and Gagne 1999

Consumer Thread class Consumer extends Thread { public Consumer(Message. Queue m) { mbox = m; } public void run() { while (true) { Date message = (Date)mbox. receive(); if (message != null) // consume the message } } private Message. Queue mbox; } Applied Operating System Concepts 5. 32 Silberschatz, Galvin, and Gagne 1999