Transcript OS Review: Thread

OS Review
Processes and Threads
Chi Zhang
[email protected]
1
Process Concept
Process – a program in execution;
process execution must progress in
sequential fashion.
A process includes
program counter
stack
data section
2
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.
3
Process Control Block (PCB)
Pointer to the next
process
4
CPU Switch From Process to
Process
5
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.
6
System Calls
 System calls provide the interface between a running
program and the operating system.
7
Single and Multithreaded Processes
Code, Data and Files are shared
8
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.
9
User Threads
Thread management done by user-level
threads library
A blocking system call will cause the entire
process to block
OS 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.
10
Many-to-One Model (User Threads)
11
Kernel Threads
Supported by the Kernel
OS 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.
12
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.
13
The thread library (user level) multiplexes (schedules) userlevel threads on the pool of LWPs for the process.
Only user-level threads currently connected to an LWP
accomplish work
For one process, one LWP is needed for every thread that
14
may block concurrently in system calls for multiple I/O threads
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
}
}
15
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
16