Chapter 4. Multithreaded Pro-
gramming
OS lab
Sun Suk KimOS lab
Sun Suk Kim
2OS Lab Sun Suk Kim
ContentsContents
1. Overview
2. Multithreading Model
3. Thread Libraries
4. Threading Issues
5. Operating-system Example
3OS Lab Sun Suk Kim
multiple threads
Introduce many concept
Look at many issues
Explore how some OSs support kernel level threads
ContentsContents
4OS Lab Sun Suk Kim
1 Overview1 Overview
A process ,in most modern OS, containing multiple threads
reg
code
stackreg
filedatacode
reg
data file
reg
stackstackstack
thread
5
Desktop PC
Some kind of Software Packages
1-1 Motivation1-1 Motivation
OS Lab Sun Suk Kim
1. Software package in Desktop
Separate process with several threads of control
Web Browser
display
retrieve data
The other process
thread
thread
Word Processor
Check spell& gram-mar
Resp key-
stroke
display
6
1-1 Motivation1-1 Motivation
OS Lab Sun Suk Kim
2. One process that contains multiple threads
Not create a separate process to service that re-quest
client server thread
(1) request(2) create new thread to service the request
(3) resume listening for additional client requests
7
1-2 Benefits1-2 Benefits
• Responsiveness– May allow a program to continue running– Increasing responsiveness to the user
• Resource sharing– Threads share the memory and resources of the
process(default)– allows an application to have several threads of activity
within the same address space
• Economy– more economical to create and context-switch threads
• Scalability– can be greatly increased in a multiprocessor architecture– Multithreading on a multi-CPU machine increases parallelism
OS Lab Sun Suk Kim
8OS Lab Sun Suk Kim
1-3 Multicore Programming1-3 Multicore Programming
• Multithreaded programming on single-core system
• Multithreaded programming on multicore system
T1 T2 T3 T4 T1 T2 T3 T4 T1 …single core
time
T1 T3 T1 T3 T1 …core 1
T2 T4 T2 T4 T2 …core 2
time
9OS Lab Sun Suk Kim
1-3 Multicore Programming1-3 Multicore Programming
• Challenging areas in programming for multicore sys-
tems– Dividing activities: find areas that can be divided into separate,
concurrent task and thus can run in parallel on individual cores.
– Balance: ensure that the tasks perform equal work of equal value
– Data splitting: the data accessed and manipulated by the concur-
rent tasks must be divided to run on separate cores
– Data dependency: where one task depends on data from another,
programmer must ensure that the execution of the tasks is syn-
chronized to accommodate the data dependency
– Testing and Debugging: is more difficult than one of single-
threaded application because it has many different execution paths
10
2 Multithreading Model2 Multithreading Model
• User thread(user level)– Supported above the kernel– Managed without kernel support
• Kernel thread(kernel level)– Supported, managed directly by OS– Windows XP, Linux, Mac OS X, Solaris,Tru64 UNIX
support kernel threads
OS Lab Sun Suk Kim
Support for threads may be provided both user or kernel level
So, relationship must exist between user threads and kernel threads
11
2-1 Many-to-One Model2-1 Many-to-One Model
• Maps many user-level threads to one kernel thread– Thread management is done by the thread library in user
space– When a thread makes a blocking system call then other
process will block
• Only one thread can access the kernel at a time– multiple threads are unable to run in parallel on multiproces-
sors
• Green thread(Solaris)GNU Potable thread
OS Lab Sun Suk Kim
k
12
2-2 One-to-One Model2-2 One-to-One Model
• Maps each user thread to a kernel thread– provides more concurrency than the many-to-one model– When a thread makes a blocking system call, allows another
thread to run
• Creating a user thread - creating the kernel thread– Creating kernel threads is make overhead – System restrict the number of threads
• Linux, Windows
OS Lab Sun Suk Kim
k k kk
13OS Lab Sun Suk Kim
2-3 Many-to-Many Model2-3 Many-to-Many Model
• Multiplexes many user threads to a smaller or equal number of kernel threads– allows creating as many user threads as the developer– When a thread performs a blocking system call
the kernel can schedule another thread for execution
• True concurrency is not gained– the kernel can schedule only one thread at a time
• Some kind of variation on this model– two level model
k kk
14
3 Thread Libraries3 Thread Libraries
• Provide APIs for creating and managing threads– to provide a library entirely in user space with no kernel sup-
port– to implement a kernel-level library supported directly by the
operating system
• Three main thread libraries– Pthreads: extension of the POSIX standard, may be provided
as either a user or kernel level library– Win32 threads: a kernel level library available on Windows
systems– Java threads: using a thread library available on the host sys-
tem
OS Lab Sun Suk Kim
15
3-1 Pthreads3-1 Pthreads
OS Lab Sun Suk Kim
main( )
pthread_attr_init( )
pthread_create( )
pthread_join( )
function
pthread_exit( )
16
3-2 Win32 Threads3-2 Win32 Threads
OS Lab Sun Suk Kim
main( )
CreateThread( )
WaitForSingleObject( )
function
return
17
4 Threading Issues4 Threading Issues
1. The fork() and exec() System Calls
2. Cancellation
3. Signal Handling
4. Thread Pools
5. Thread-Specific Data
6. Scheduler Activations
OS Lab Sun Suk Kim
18
4-1 The fork() and exec() System Calls4-1 The fork() and exec() System Calls
• fork( )– does the new process duplicate all threads– duplicates only the thread that invoked the fork( ) system
call
• exec( )– specified in the parameter to exec( ) will replace the entire
process (all thread)
• fork( ) → exec( )– exec( ) is called immediately after forking: duplicating is un-
necessary• the program specified in the parameters to exec( ) will replace
the process– separate process does not call exec( ) after forking
→ the separate process should duplicate all threadsOS Lab Sun Suk
Kim
19
4-2 Cancellation4-2 Cancellation
• the task of terminating a thread before it has com-pleted
• Asynchronous cancellation– One thread immediately terminates the target thread– the difficulty with asynchronous cancellation
• resources have been allocated to a canceled thread• canceled while in the midst of updating data it is sharing with
other threads
• Deferred cancellation– The target thread periodically checks whether it should ter-
minate, allowing it an opportunity to terminate itself in an orderly fashion
– can be canceled safely• occurs only after the target thread has checked a flag to deter-
mine
OS Lab Sun Suk Kim
20
4-3 Signal Handling4-3 Signal Handling
• Patterns of signal– A signal is generated by the occurrence of a particular event– A generated signal is delivered to a process– Once delivered, the signal must be handled
• Synchronous or Asynchronous signals– Synchronous: If a running program performs either illegal
memory access and division by 0• are delivered to the same process that performed the operation
that caused the signal– Asynchronous: when a signal is generated by an event ex-
ternal to a running process• an asynchronous signal is sent to another process
OS Lab Sun Suk Kim
21
4-4 Thread Pools4-4 Thread Pools
• is a solution to potential problems in multithreaded programs– multithreaded programs have potential problems: time and
space
• Benefits of thread pools– Servicing a request with an existing thread is usually faster
than waiting to create a thread– A thread pool limits the number of threads that exist at any
one point• particularly important on systems that cannot support a large
number of concurrent threads
OS Lab Sun Suk Kim
22
4-5 Thread-Specific Data4-5 Thread-Specific Data
• The sharing of data provides one of the benefits of multithreaded programming– each thread might need its own copy of certain data– call such data thread-specific data– Most thread libraries provide some form of support for
thread-specific data
OS Lab Sun Suk Kim
23OS Lab Sun Suk Kim
4-6 Scheduler Activations4-6 Scheduler Activations
• Communication between the kernel and the thread library– Many systems implementing either the many-to-many or the
two-level model– How to allow the number of kernel threads to be dynamically
adjusted to help ensure the best performance
• LWP (Lightweight Process)– To the user-thread library, the LWP appears to be a
virtual processor– The application can schedule a user thread to run on
virtual processor– each LWP is attached to a kernel thread that the
operating system schedules to run on physical processor
k
LWP
lightweight process
24
5 Operating-system Example5 Operating-system Example
1. Windows XP Threads
2. Linux Threads
OS Lab Sun Suk Kim
25
5-1 Windows XP Threads5-1 Windows XP Threads
• Uses the one-to-one model– each user-level thread maps to an associated kernel thread– also provides support for a fiber library, which provides the
functionality of the many-to-many model• The primary data structures of a thread
OS Lab Sun Suk Kim
thread start ad-dress
pointer to parent process
…
scheduling and synchronization
information
kernel stack
…
thread identifier
user stack
thread-local stor-age
…
ETHREAD KTHREAD TEB
kernel space user space
26OS Lab Sun Suk Kim
5-2 Linux Threads5-2 Linux Threads
• clone( ) system call– Linux does not distinguish between processes and threads →
uses the term task– determine how much sharing is to take place between the
parent and child tasks– flags of clone( )
– fork( ): new task requires a copy of all the associated data structures of the parent process
– clone( ): new task points to the data structures of the parent task
flag meaning
CLONE_FS File-system information is shared
CLONE_VM The same memory space is shared
CLONE_SIGHAND Signal handlers are shared
CLONE_FILES The set of open files is shared
Top Related