1 / 16

OS Review Processes and Threads

OS Review Processes and Threads. Chi Zhang czhang@cs.fiu.edu. Process Concept. Process – a program in execution; process execution must progress in sequential fashion. A process includes program counter stack data section. Process State. As a process executes, it changes state

spike
Download Presentation

OS Review Processes and Threads

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


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

  2. Process Concept • Process – 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 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. Many-to-One Model (User Threads)

  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. 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 work • For 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

More Related