CS 217 Operating Systems
This lecture delves into the fundamentals of multithreaded programming, highlighting the concept of threads as lightweight processes that enable efficient CPU utilization. It discusses Java thread libraries, the advantages of using threads for responsiveness and resource sharing, and the challenges associated with synchronization. Moreover, it compares threads with processes, outlines the benefits of multithreading in various applications including servers and embedded systems, and explores different multithreading models such as many-to-one and one-to-one.
CS 217 Operating Systems
E N D
Presentation Transcript
CS 217 Operating Systems Multithreaded Programming Lecture 08 SomiaRazzaq NFC IET Slides adopted from Silbershatz, Galvin and Gagne
Today’s Objectives • To introduce the notion of a thread • a fundamental unit of CPU utilization that forms the basis of multithreaded computer systems • To discuss the Java thread libraries
Issues with Processes • The fork() system call is expensive (it requires memory to memory copy of the • executable image of the calling process and allocation of kernel resources to the • child process) • IPC is required to pass information between a parent and its child processes.
Thread Concept • A thread is a “lightweight” process which executes within the address space of a process. • A thread can be scheduled to run on a CPU as an independent unit and terminate. • Multiple threads can run simultaneously.
Thread Concept • Threads have their own • Thread ID • CPU context (PC, SP, register set, etc.) • Stack • Priority • errno
Thread Concept • Threads share • Code and data • Open files (through the PPFDT) • Current working directory • User and group IDs • Signal setups and handlers • PCB
Threads are Similar to Processes • A thread can be in states similar to a process (new, ready, running, blocked, terminated) • A thread can create another thread
Threads vs. Processes • Processes • Heavyweight - large startup costs • Separate address space • Cooperate with simple read/write streams (pipes) • Synchronization is easy -typically don't have shared address space (i.e. in some sense, fewer opportunities for bugs) • Threads • Lightweight -easy to create/destroy • All in one address space • Can share memory/variables directly • May require more complex synchronization logic to make the shared memory work (potentially hard)
Advantages of Threads • Responsiveness • Multi-threaded servers (e.g., browsers) can allow interaction with user while a thread is formulating response to a previous user query (e.g., rendering a web page) • Keep the GUI responsive by separating the "worker" thread from the GUI thread -this helps an application feel fast and responsive
Advantages of Threads • Resource sharing • Process resources (code, data, etc.) • OS resources (PCB, PPFDT, etc.)
Advantages of Threads • Economy • Take less time to create, schedule, and terminate • Solaris 2: thread creation is 30 times faster than process creation and thread switching is five times faster than process switching
Advantages of Threads • Performance in multi-processor and multi-threaded architectures (e.g., Intel’s P4 HT) • Multiple threads can run simultaneously
Disadvantages of Threads • Resource sharing— synchronization needed between threads • Difficult to write and debug multi-threaded programs
Examples of multithreaded programs • Embedded systems • Elevators, Planes, Medical systems, Wristwatches • Single Program, concurrent operations • Most modern OS kernels • Internally concurrent because have to deal with concurrent requests by multiple users • Database Servers • Access to shared data by many concurrent users • Also background utility processing must be done
Examples of multithreaded programs (con’t) • Network Servers • Concurrent requests from network • Again, single program, multiple concurrent operations • File server, Web server, and airline reservation systems • Parallel Programming (More than one physical CPU) • Split program into multiple threads for parallelism
Multicore Programming • Multicore systems putting pressure on programmers • Challenges include • Dividing activities • Balance • Data splitting • Data dependency • Testing and debugging
Multithreaded Models • Support for threads may be provided at • User level or • Kernel level
User Threads Thread management done by user-level threads library without kernel support Three primary thread libraries: POSIX Pthreads Win32 threads Java threads
Kernel Threads Supported and managed by the OS Kernel Examples of OS supporting kernel thread Windows XP/2000 Solaris Linux Tru64 UNIX Mac OS X
Multithreading Models A relationship must exist between the user and kernel threads Many-to-One One-to-One Many-to-Many
Many-to-One Many user-level threads mapped to single kernel thread Examples: Solaris Green Threads GNU Portable Threads
Many-to-One Model • Thread management done by thread library in user space – efficient • Entire process blocks if a thread makes a blocking system call • Only one thread can access kernel at a time, multiple threads cannot run in parallel on multiprocessors
One-to-One Model Each user-level thread maps to a kernel thread More concurrency than Many-to-One Model Allows other thread to run when one thread makes a blocking system call Multiple threads can access kernel at a time, allows multiple threads to run in parallel on multiprocessors Drawback: creating a user thread requires creating a kernel thread Expensive – most implementation constrain the number of threads supported Examples Windows NT/XP/2000 Linux Solaris 9 and later
Many-to-Many Model Allows many user level threads to be mapped to many kernel threads Allows the operating system to create a sufficient number of kernel threads When a thread performs a blocking system call, the kernel can schedule another thread for execution Solaris prior to version 9 Windows NT/2000 with the ThreadFiber package
Two-level Model Similar to M:M, except that it allows a user thread to be bound to kernel thread Examples IRIX HP-UX Tru64 UNIX Solaris 8 and earlier
Thread Libraries • Thread library provides programmer with API for creating and managing threads • Two primary ways of implementing • Library entirely in user space • Kernel-level library supported by the OS • Three main thread libraries are in use today • POSIX Pthreads (user or kernel-level) • Win32(kernel-level) • Java(directly managed in java programs)
Java Threads • Java threads are managed by the JVM • Java threads may be created by: • Implementing the Runnable interface
Thread creation steps (Using interface) • Step 1 - Implement the Runnable Interface class Worker implements Runnable • Step 2 - Provide an Implementation of run method public void run ( ){ // write thread behavior // code that will execute by thread } • Step 3 - Instantiate Thread object by passing runnable object in constructor Worker w = new Worker(“first”); Thread t = new Thread (w); • Step 4 – Start thread t.start()
