1 / 30

CMSC 421 Spring 2004 Section 0202

CMSC 421 Spring 2004 Section 0202. Part II: Process Management Chapter 5 Threads. Contents. Overview Multithreading Models Threading Issues Pthreads Solaris 2 Threads Windows 2000 Threads Linux Threads Java Threads. Lightweight Process and Heavyweight Process.

Download Presentation

CMSC 421 Spring 2004 Section 0202

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. CMSC 421 Spring 2004 Section 0202 Part II: Process Management Chapter 5 Threads

  2. Contents • Overview • Multithreading Models • Threading Issues • Pthreads • Solaris 2 Threads • Windows 2000 Threads • Linux Threads • Java Threads Operating System Concepts

  3. Lightweight Process and Heavyweight Process • Lightweight Process (LWP) or thread • Basic unit of CPU control • Typically has private • Id, PC, register set, stacks, local storage • Shares OS resources with containing process • Address space (Code section, data section), open files, etc • Heavyweight Process (HWP) • Single thread Operating System Concepts

  4. Single and Multithreaded Processes Operating System Concepts

  5. Benefits • Responsiveness • Interactive program responds to user even when some threads are blocked doing other activities • Resource Sharing • Shared address space, etc • Economy • Lower overhead in creating and context switching threads than processes • context switch is 5 times faster • Thread creation is 30 times faster • Utilization of multi-processor architectures • Multiple threads can run on multiple processors Operating System Concepts

  6. User Threads • Thread management done by a user-level threads library • Kernel is unaware of user-level threads • User-level threads are faster to create and manage • However, if a thread is blocked on a system call, the process is blocked too, and none of its other threads continues to run • Examples - POSIX Pthreads - Mach C-threads - Solaris 2 threads Operating System Concepts

  7. Kernel Threads • Thread management is supported by the Kernel • Slower than user threads • But kernel can schedule another thread when one thread performs a blocking system call • Examples - Windows 95/98/NT/2000 - Solaris - Tru64 UNIX - BeOS - Linux Operating System Concepts

  8. Multithreading Models • Three models for implementing threads • Many-to-One • One-to-One • Many-to-Many Operating System Concepts

  9. Many-to-One Model Operating System Concepts

  10. Many-to-One • Many user-level threads are mapped to a single kernel thread. • Multiple threads CANNOT run in parallel in a multiprocessor system • A blocked thread blocks its process • Used on systems that do not support kernel threads. • Example • Solaris 2 Green Threads Library Operating System Concepts

  11. One-to-one Model Operating System Concepts

  12. One-to-One • Each user-level thread maps to kernel thread. • Can burden OS and slowdown application when many threads are created (due to kernel overhead) • Examples - Windows 95/98/NT/2000 - OS/2 Operating System Concepts

  13. Many-to-Many Model Operating System Concepts

  14. 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, and map user threads to them • Addresses the shortcomings of the many-to-one and one-to-one models • Examples • Solaris 2 • Windows NT/2000 with the ThreadFiber package Operating System Concepts

  15. Threading Issues • Semantics of fork() and exec() system calls • Thread cancellation • Signal handling • Thread pools • Thread specific data Operating System Concepts

  16. fork() and exec() semantics • fork() • Does it duplicate ALL threads of the forking process? • Two flavors: one that duplicates and one that does not • Exec() • Replaces the whole process • Including all threads (LWPs) Operating System Concepts

  17. Thread Cancellation • Canceling a target thread • Asynchronous cancellation (immediate termination) • Deferred cancellation • Target thread periodically checks if it should terminate • Issues: • reclaiming resources of cancelled target thread • Shared resources with other threads • Cancellation points Operating System Concepts

  18. Signal Handling • Signal => Notify the process of the occurrence of a certain event • Types of signals • Synchronous • Delivered to the same process that generated the signal • Illegal memory access, division by zero, overflow • Asynchronous • Generally, delivered to a different process than the one generating the signal • <control><C>, timer expiry • Signals handled using • Default signal handler (run by the kernel) • User-defined signal handler Operating System Concepts

  19. Signal Handling (Cont.) • Options for delivering signals (depending on signal) • Only to the thread that generated the signal • To all threads of a process • To all threads not blocking the signal • To a specific/dedicated thread • Threads many choose to block certain signals Operating System Concepts

  20. Thread Pools and Thread-specific Data • Thread pools • Creating a large number of threads in a system can exhaust system resources • Allocate a pool of thread’s • Allocate available threads from the thread pool to a new “thread” • Reduces thread creation time when a request arrives • Thread-specific data • Need for supporting private storage for threads that need to manage their own private data Operating System Concepts

  21. Pthreads • a POSIX standard (IEEE 1003.1c) API for thread creation, synchronization, and management • API specifies behavior of the thread library, implementation is up to development of the library. • Common in UNIX operating systems Operating System Concepts

  22. Solaris 2 Threads • Implements the Pthread API + support for user and kernel threads • Uses LWP to multiplex user threads • Implements many-to-many model • LWP reside in kernel space • Allocates a kernel thread to each LWP • User threads can be bound to a LWP or can be unbound • Each user thread contains • Thread ID, register set (PC and stack pointer), stack, , and priority • Each LWP contains • Register set for running user thread, stack, memory, and accounting info Operating System Concepts

  23. Solaris 2 Threads Operating System Concepts

  24. Solaris Process Operating System Concepts

  25. Pthreads Example #include <pthread.h> #include <stdio.h> int sum = 0; /* shared data of the threads */ void *runner(void *p); int main(int argc, char *argv[]) { pthread_attr_t attr; pthread_t tid; pthread_attr_init(&attr); pthread_create(&tid, &attr, runner, argv[1]); /* create a thread and exec runner*/ pthread_join(tid, NULL); /* wait for thread to finish exec */ printf(“%d\n”, sum); exit(0); } void *runner(void *param) { int n = 0, i; n = atoi(param); sum = 0; for(i=0; i;<n; i++) sum += i; pthread_exit(0); } Operating System Concepts

  26. Windows 2000 Threads • Implements the one-to-one mapping. • Each thread contains - a thread id - register set - separate user and kernel stacks - private data storage area Operating System Concepts

  27. Linux Threads • Thread creation is done through clone() system call • Linux’s trick • Store process information in separate structures and use pointers to point to them instead of storing it directly in the data structure for the process • Clone() allows a child task to share the address space of the parent task (process) • Linux refers to them as tasks rather than threads. Operating System Concepts

  28. Java Threads • Java threads may be created by: • Extending Thread class • Implementing the Runnable interface • Java threads are managed by the JVM. • Java thread implementation depends on how the JVM is implemented on the host OS • Can be one-to-one for JVMs on Windows 2000 etc systems • Can be many-tone on Solaris 2 green thread JVM systems Operating System Concepts

  29. Java Thread Example class Summation extends Thread { private int bound = 0; public Summation(int n) { bound = n; } public void run() { int sum = 0; for(int I=0; I<bound; I++) sum += I; System.out.println(“Sum = “ + sum); } } public class Test { public static void main(String[] args) { Summation thr = new Summation(Integer.parseInt(args[0]); thr.start(); } } Operating System Concepts

  30. Java Thread States Operating System Concepts

More Related