Processes and Threads

• This chapter examines advanced concepts related to process management
• The original concept of a process has two components: resources and execution
• Operating systems are developing a construct known as a thread to address the two components

Processes and Threads

• A process is a unit of resource allocation as well as a unit of protection
• A process has a virtual address space for the process image
• Processes are protected to prevent interference with resources, which can include; processors, other processes (for interprocess communication), files, and I/O resources
• The execution of a process follows an execution path
• A process has an execution state; Running, Ready etc
• A process also has a dispatching priority that the OS can schedule if needed
• A thread is the unit of dispatching
• The unit of resource ownership is a process or task

Multithreading

• An operating system’s ability to support multiple, concurrent paths of execution within a single process
• A single thread of execution per process is a single-threaded approach
• A Java run-time environment uses one process with multiple threads
• Windows and Solaris use multiple processes that support multiple threads

Multithreaded Environment

• Processes are the unit of resource allocation and a unit of protection

• Processes have a virtual address space that holds the process image

• Processes have access to processors, other processes (for interprocess communication), files, I/O resources

• Threads exist within a process

• Threads have an execution state (Running, Ready, etc.)

• When threads are not running, their context is saved

• Threads have an execution stack

• Some per-thread static storage for local variables

• Threads have access to the memory and resources of its process, which is shared with all other threads in that process

• It takes less time to create/terminate a thread than a process

• It takes less time to switch between two threads within a process than to switch between processes

• Threads enhance efficiency in communication between different executing programs

• The kernel intervenes to provide protection and mechanisms for communication between independent processes

• Threads within the same process share memory and files, therefore they can communicate without the kernel

Thread States and Operations

• Key states for a thread are Running, Ready, and Blocked

• There are no Suspend states with threads

• Basic thread operations that cause a change in state consist of the following,

• Spawn: New process spawns a thread for that process

• Block: Thread waits for event

• Unblock: Event for which a thread is blocked occurs

• Finish: Thread completes; register context and stacks are deallocated

Remote Procedure Call (RPC)

• Remote procedure calls (RPCs) to two different hosts is used to get a combined result
• Without threads, results are obtained in sequence; program waits for response from each server
• With threads, requests processed with substantial speedup

Thread Synchronization

• Threads of a process share the same address space and other resources like open files
• Any alteration of a resource by one thread affects the environment of the other threads in the same process
• The activities of the various threads synchronize so they don't interfere with each other or corrupt data structures

Types of Threads: User-Level Threads

• The two categories of thread implementation include: User-level threads (ULTs) and kernel-level threads (KLTs)
• All of the work of thread management is done by the application using a ULT
• The kernel isn't aware of the existence of threads

ULT Advantages

• Thread switching doesn’t require kernel mode privileges
• Scheduling can be application-specific
• ULTs can run on any OS

ULT Disadvantages

• Many system calls are blocking, which blocks the entire process
• Multithreaded applications cannot take advantage of multiprocessing
• A kernel assigns one process to only one processor at a time

Kernel-Level Threads (KLTs)

• All of the work of thread management is done by the kernel; uses an application programming interface (API) to the kernel thread facility

KLT Advantages

• Kernel can schedule multiple threads from the same process on multiple processors
• If one thread in a process is blocked, the kernel can schedule another thread of the same process
• Kernel routines are multithreaded too

KLT Disadvantage

• Requires a mode switch to the kernel to transfer control from one thread to another within the same process, which can be slow

Combined ULT/KLT Approaches

• Provide a combined ULT/KLT facility
• Thread creation completed in user space as well as scheduling and synchronization of threads
• The application maps multiple ULTs onto some number of KLTs
• The programmer adjusts the number of KLTs for a particular application to achieve the best overall results
• Multiple threads can run in parallel on multiple processors
• A system call need not block the entire process
• Minimizes the disadvantages of all approaches

Relationships Between Threads and Processes

• Traditional OS had 1:1 relationship between thread and process
• Other systems include:
• M:1: Processes an address space and dynamic resource ownership, multiple threads may be created and executed there
• 1:M: The thread may migrate from one process environment to another, allowing the thread to be easily moved to distinct systems
• M:N: Combines attributes of M:1 and 1:M cases