1

OS Review

Processes and Threads

Chi Zhangczhang@cs.fiu.edu

2

Process ConceptProcess – a program in execution;

process execution must progress in sequential fashion.

A process includes program counter stack data section

3

Process State As a process executes, it changes state

new: The process is being created. running: Instructions are being executed. waiting: The process is waiting for some event to occur. ready: The process is waiting to be assigned to a process. terminated: The process has finished execution.

4

Process Control Block (PCB)

Pointer to the next process

5

CPU Switch From Process to Process

6

Context Switch

When CPU switches to another process, the system must save the state of the old process and load the saved state for the new process.

Context-switch time is overhead; the system does no useful work while switching.

Time dependent on hardware support.

7

System Calls System calls provide the interface between a running

program and the operating system.

8

Single and Multithreaded Processes

Code, Data and Files are shared

9

Benefits Responsiveness

User interaction in parallel with data retrieval Utilization of MP Architectures Resource Sharing between Threads (vs.

Process) E.g. Synchronization by accessing shared data

Economy (vs. Process) If the task is the same, why not share the code? In Solaris 2, creating a process is about 30 times

slower than threads. Context switch threads is about 5 times slower.

10

User Threads

Thread management done by user-level threads library

A blocking system call will cause the entire process to blockOS is unaware of threads

The kernel cannot schedule threads on different CPUs.

Example: Pthread, a POSIX standard (IEEE 1003.1c) API for thread creation and synchronization.

11

Many-to-One Model (User Threads)

12

Kernel Threads

Supported by the KernelOS manages threads

Slower to create and manage because of system calls

A blocking system call will not cause the entire process to block.

The kernel can schedule threads on different CPUs.

13

Many-to-Many Model (Solaris 2) Allows many user level threads to be mapped to

many (fewer) kernel threads. Allows the operating system to create a sufficient

number of kernel threads.

14

The thread library (user level) multiplexes (schedules) user-level threads on the pool of LWPs for the process.Only user-level threads currently connected to an LWP accomplish workFor one process, one LWP is needed for every thread that may block concurrently in system calls for multiple I/O threads

15

Java Threads

class Command implements Runnable {String commandLine; Command(String commandLine) { this.commandLine = commandLine; } public void run() {

// Do what commandLine says to do // yield () the thread pause temporally

} }

16

Java Threads

String line = inputStream.readLine(); int numberOfCommands = // count how many comands

there are on the line Thread t[] = new Thread[numberOfCommands]; for (int i=0; i<numberOfCommands; i++) {

String c = // next command on the line t[i] = new Thread(new Command(c)); t[i].start();

} for (int i=0; i<numberOfCommands; i++) {

t[i].join(); // wait until the end of t[i]}

Also