Download Lecture OS - University of Wisconsin

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
Outlines
 Process Aspects
 process vs. Threads
 Multithreading Process
 User and Kernel Threads
 Thread Pool
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
Process vs. Thread
 Process
 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
Process Types
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
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
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
Thread States
 States associated with a change in thread state
 Spawn
• Spawn another thread



Block
Unblock
Finish
• De-allocate register context and stacks
Thread States Example:
 Remote Procedure Call (RPC) Using Threads
Thread Types
 User-Level Threads
 Kernel-Level Threads
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
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
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
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 kernellevel threads

allocation is specific to a particular machine (more k.
threads may be allocated on a multiprocessor)
Multithreading Models
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
Thread APIs
 POSIX threads (pthreads)




Win32 threads



A POSIX standard (IEEE 1003.1c) 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
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