1 Chapter 4 Threads Threads: Resource ownership and execution

2 Processes and Threads Processes have two characteristics: –Resource ownership – a process includes an address space to hold the process image and may be allocated control or ownership of resources –Scheduling/execution – process execution follows an execution path that may be interleaved with other processes These two characteristics are treated independently by the operating system

3 Processes and Threads The unit of dispatching is referred to as a thread or lightweight process The unit of resource ownership is referred to as a process or task

4 Multithreading The ability of an OS to support multiple, concurrent paths of execution within a single process.

5 Single Thread Approaches MS-DOS supports a single user process and a single thread Some UNIX, support multiple user processes but only support one thread per process

6 Multithreading Java run-time environment is a single process with multiple threads Multiple processes and threads are found in Windows, Solaris, and many modern versions of UNIX

7 Processes In a multithreaded environment, a process is defined as –a unit of resource allocation: a virtual address space which holds the process image –a unit of protection: protected access to processors, other processes (for IPC), files, I/O resources

8 One or More Threads in Process Each thread has –An execution state (running, ready, etc.) –Saved thread context when not running –An execution stack –Some per-thread static storage for local variables –Access to the memory and resources of its process (all threads of a process share this)

9 One view… One way to view a thread is as an independent program counter operating within a process.

10 Threads vs. processes

11 Threads vs. processes The thread control block contains register values, priority, and other thread-related state information. All threads of a process share the state and resources of that process. –reside in the same address space –have access to the same data when one thread alters a data, other threads see the results when one thread opens a file, other threads can also access that file

12 Benefits of Threads Takes less time to create a new thread than a process (can be 10 times faster) Less time to terminate a thread than a process Switching between two threads takes less time that switching processes Threads can communicate with each other –without invoking the kernel

13 Benefits of Threads If an application is implemented as a set of related units of execution, it is far more efficient to do so as a collection of threads rather than a collection of separate processes

14 Example Applications of Threads In a file server, a new thread can be spawned for the file management program per each new file request  multiple threads within the same process can be executing simultaneously on different processors In a spreadsheet program, one thread could read user input while another thread executes user commands In a word processor, a thread can be created to do periodic backup asynchronously In a multithreaded process, one thread can compute one batch of data while another thread reads the next batch from an I/O device

15 Threads vs. processes Like processes, threads have execution states –Running, Ready, and Blocked Some states are process-level –Suspend: if a process is swapped out, all of its threads are necessarily swapped out because they all share the address space of the process

16 Threads vs. processes Like processes, thread may synchronize with one another. –Any alteration of a resource by one thread affects other threads in the same process consider two threads each try to add an element to a linked list at the same time

17 Example: Remote Procedure Call Consider: –A program that performs two remote procedure calls (RPCs) to two different hosts to obtain a combined result.

18 RPC Using Single Thread The program has to wait for a response from each server in turn.

19 RPC Using One Thread per Server The program waits concurrently for the two replies.

20 Multithreading on a Uniprocessor Interleaving of multiple threads within multiple processes on a uniprocessor