1. 1 OS Review Processes and Threads Chi Zhang czhang@cs.fiu.edu

2. 2 Process Concept Process – a program in execution; process execution must progress in sequential fashion. A process includes  program counter  stack  data section

3. 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. 4 Process Control Block (PCB) Pointer to the next process

5. 5 CPU Switch From Process to Process

6. 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. 7 System Calls System calls provide the interface between a running program and the operating system.

8. 8 Single and Multithreaded Processes  Code, Data and Files are shared

9. 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. 10 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.

11. 11 Many-to-One Model (User Threads)

12. 12 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.

13. 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. 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 work  For one process, one LWP is needed for every thread that may block concurrently in system calls for multiple I/O threads

15. 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. 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