Download presentation
Presentation is loading. Please wait.
Published byRodger Holt Modified over 9 years ago
1
Computer Architecture and Operating Systems CS 3230: Operating System Section Lecture OS-2 Threads
Department of Computer Science and Software Engineering University of Wisconsin-Platteville
2
Outlines Process Aspects process vs. Threads Multithreading Process
User and Kernel Threads Thread Pool
3
Process Aspects Process can be viewed two ways
unit of resource ownership address space, containing program code and data open files, may be using an I/O device unit of scheduling execution path that may be interleaved with other processes These two aspects are treated independently by the operating system process = unit of resource ownership thread = unit of scheduling Operating system supports multiple threads of execution within a single process
4
Process vs. Thread Process Thread A process is a multithread where
address space, program code, global variables, heap, OS resources : files, I/O devices Thread is a single sequential execution stream within a process A process is a multithread where Each thread has its own (other threads can access but shouldn’t) registers, program counter (PC) , stack, stack pointer (SP) All threads shares process resources Threads executes concurrently Each thread can block, fork, terminate, synchronize
5
Process Types
6
Multithreading Process: When
Programs require multithreading programs with multiple independent tasks to provide quick user-response while carrying out main task server which needs to process multiple independent requests simultaneously OS kernel repetitive numerical tasks — break large problem down into small problems and assign each one to a separate thread programs difficult to multithread: programs that don’t have multiple concurrent tasks multi-task programs that require protection between tasks
7
Benefits of Threads Takes less time to create a new thread than a process Less time to terminate a thread than a process Less time to switch between two threads within the same process Since threads within the same process share memory and files, they can communicate with each other without invoking the kernel
8
Thread Termination Suspending a process involves suspending all threads of the process all process threads share the same address space Termination of a process, terminates all threads within the process
9
Thread States States associated with a change in thread state Spawn
Spawn another thread Block Unblock Finish De-allocate register context and stacks
10
Thread States Example:
Remote Procedure Call (RPC) Using Threads
11
Thread Types User-Level Threads Kernel-Level Threads
12
User-Level Threads provide a library of functions to allow user processes to manage (create, delete, schedule) their own threads OS is not aware of threads advantages: doesn’t require modification to the OS simple representation — each thread is represented simply by a PC, registers, stack, and a small control block, all stored in the user process’ address space simple management — creating a new thread, switching between threads, and synchronization between threads can all be done without intervention of the kernel fast — thread switching is not much more expensive than a procedure call flexible — CPU scheduling (among those threads) can be customized to suit the needs of the algorithm
13
User-Level Threads disadvantages:
lack of coordination between threads and OS kernel process as a whole gets one time slice same time slice, whether process has 1 thread or 1000 threads also — up to each thread to relinquish control to other threads in that process requires non-blocking system calls otherwise, entire process will blocked in the kernel, even if there are runnable threads left in the process
14
Kernel-Level Threads kernel provides system calls to create and manage threads advantages kernel has full knowledge of all threads - scheduler may choose to give a process with 10 threads more time than process with only 1 thread good for applications that frequently block (e.g., server processes with frequent interprocess communication) disadvantages: slower — thread operations are significantly slower than for user-level threads significant overhead and increased kernel complexity — kernel must manage and schedule threads as well as processes - requires a full thread (task) control block (TCB) for each thread
15
Multithreading Models
Many-to-One (Solaris’ green threads) – all user threads are mapped to one kernel thread: same problems as with user threads One-to-One (Windows XP, OS/2) – one user thread to one kernel thread programmer has better control of concurrency does not block the process on one thread blocking may potentially waste resources Many-to-Many – multiplexes many user-level threads to a smaller or equal number of kernel-level threads allocation is specific to a particular machine (more k. threads may be allocated on a multiprocessor)
16
Multithreading Models
17
Thread Pools threads may not be created infinitely – overwhelm computer resources consider web-server on-demand thread creation may not be fast enough thread pool create a number of threads in a pool where they remain blocked until activated activate when request arrives if more requests than threads – extra requests have to wait performance controllable process size fast response until pool exhausted
18
Thread APIs POSIX threads (pthreads) Win32 threads Java threads
A POSIX standard (IEEE c) API for thread creation and synchronization Common in UNIX operating systems (Solaris, Linux, MacOS X) implemented on top of “native” OS threads or as a user-level package Win32 threads one-to-one mapping implemented on Windows OSes Java threads specified as part of Java maintained by JVM implemented on native threads or as a user-level package
Similar presentations
© 2024 SlidePlayer.com. Inc.
All rights reserved.