Chapter 4: Multithreaded

Programming

Operating System Concepts – 8th Edition, Silberschatz, Galvin and Gagne ©2009
 Chapter 4: Multithreaded Programming

 Overview
 Multithreading Models
 Thread Libraries
 Threading Issues
 Operating System Examples
 Windows XP Threads
 Linux Threads

Operating System Concepts – 8th Edition 4.2 Silberschatz, Galvin and Gagne ©2009
 Single and Multithreaded Processes

Operating System Concepts – 8th Edition 4.4 Silberschatz, Galvin and Gagne ©2009
 Benefits
1. Responsiveness. Multithreading an interactive application may allow a program to
continue running even if part of it is blocked or is performing a lengthy operation, thereby increasing
responsiveness to the user. For instance, a multithreaded Web browser could allow user interaction in
one thread while an image was being loaded in another thread.
2. Resource sharing. Processes may only share resources through techniques such as shared
memory or message passing. Such techniques must be explicitly arranged by the programmer.
However, threads share the memory and the resources of the process to which they belong by default.
The benefit of sharing code and data is that it allows an application to have several different threads
of activity within the same address space.
3. Economy. Allocating memory and resources for process creation is costly. Because threads
share the resources of the process to which they belong, it is more economical to create and context-
switch threads. Empirically gauging the difference in overhead can be difficult, but in general it is
much more timtime-consuming create and manage processes than threads. In Solaris, for example,
creating a process is about thirty times slower than is creating a thread, and context switching is about
five times slower.
4. Scalability. The benefits of multithreading can be greatly increased in a multiprocessor
architecture, where threads may be running in parallel on different processors. A single-threaded
process can only run on one processor, regardless of how many are available. Multithreading on a
multi-CPU machine increases parallelism. We explore this issue further in the following section.

Operating System Concepts – 8th Edition 4.5 Silberschatz, Galvin and Gagne ©2009
 Multicore Programming
 Multicore systems put pressure on programmers, challenges include
1. Dividing activities. This involves examining applications to find areas that
can be divided into separate, concurrent tasks and thus can run in parallel on individual
cores.
2. Balance. While identifying tasks that can run in parallel, programmers must also
ensure that the tasks perform equal work of equal value. In some instances, a certain
task may not contribute as much value to the overall process as other tasks; using a
separate execution core to run that task may not be worth the cost.
3. Data splitting. Just as applications are divided into separate tasks, the data
accessed and manipulated by the tasks must be divided to run on separate cores.
4. Data dependency. The data accessed by the tasks must be examined for
dependencies between two or more tasks. In instances where one task depends on data
from another, programmers must ensure that the execution of the tasks is synchronized
to accommodate the data dependency. We'll examine such strategies later.
5. Testing and debugging. When a program is running in parallel on multiple
cores, there are many different execution paths. Testing and debugging such concurrent
programs is inherently more difficult than testing and debugging single-threaded
applications.

Operating System Concepts – 8th Edition 4.6 Silberschatz, Galvin and Gagne ©2009
 Multithreaded Server Architecture

Operating System Concepts – 8th Edition 4.7 Silberschatz, Galvin and Gagne ©2009
 Concurrent Execution on a Single-core System

Operating System Concepts – 8th Edition 4.8 Silberschatz, Galvin and Gagne ©2009
 Parallel Execution on a Multicore System

Operating System Concepts – 8th Edition 4.9 Silberschatz, Galvin and Gagne ©2009
 User Threads
 Thread management done by user-level threads library

 Three primary thread libraries:

 POSIX Pthreads
 Win32 threads
 Java threads

Operating System Concepts – 8th Edition 4.10 Silberschatz, Galvin and Gagne ©2009
 Kernel Threads
 Supported by the Kernel

 Examples
 Windows XP/2000
 Solaris
 Linux
 Tru64 UNIX
 Mac OS X

Operating System Concepts – 8th Edition 4.11 Silberschatz, Galvin and Gagne ©2009
 Multithreading Models
 Many-to-One

 One-to-One

 Many-to-Many
 Two-level Mod

Operating System Concepts – 8th Edition 4.12 Silberschatz, Galvin and Gagne ©2009
 Many-to-One
 Many user-level threads mapped to single kernel thread
 Examples:
 Solaris Green Threads
 GNU Portable Threads

Operating System Concepts – 8th Edition 4.13 Silberschatz, Galvin and Gagne ©2009
 One-to-One
 Each user-level thread maps to kernel thread
 Examples
 Windows NT/XP/2000
 Linux
 Solaris 9 and later

Operating System Concepts – 8th Edition 4.14 Silberschatz, Galvin and Gagne ©2009
 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
 Solaris prior to version 9
 Windows NT/2000 with the
ThreadFiber package

Operating System Concepts – 8th Edition 4.15 Silberschatz, Galvin and Gagne ©2009
 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

Operating System Concepts – 8th Edition 4.16 Silberschatz, Galvin and Gagne ©2009
 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

Operating System Concepts – 8th Edition 4.17 Silberschatz, Galvin and Gagne ©2009
 Pthreads
 Pthreads refers to the POSIX standard (IEEE 1003.1c) defining an API for
thread creation and synchronization. This is a specification for thread
behavior, not an implementation.
 May be provided either as user-level or kernel-level
 API specifies the behavior of the thread library, implementation is up to the
development of the library.
 Operating system designers may implement the specification in any way
they wish.
 Numerous systems implement the Pthreads specification, including Solaris,
Linux, Mac OS X, and Tru64 UNIX. Shareware implementations are also
available in the public domain for the various Windows operating systems.

Operating System Concepts – 8th Edition 4.18 Silberschatz, Galvin and Gagne ©2009
 Win32 Threads
 The technique for creating threads using the Win32 thread library is similar to the
Pthreads technique in several ways.
 Threads are created in the Win32 API using the CreateThread() function,
and—just as in Pthreads—a set of attributes for the thread is passed to this function.
 These attributes include security information, the size of the stack, and a flag that
can be set to indicate if the thread is to start in a suspended state.

Operating System Concepts – 8th Edition 4.20 Silberschatz, Galvin and Gagne ©2009
 Java Threads
 Java threads are managed by the JVM

 Typically implemented using the threads model provided by

underlying OS

 Java threads may be created by:

 Extending Thread class

 Implementing the Runnable interface

Operating System Concepts – 8th Edition 4.23 Silberschatz, Galvin and Gagne ©2009
 Threading Issues

 Semantics of fork() and exec() system calls

 Thread cancellation of target thread
 Asynchronous or deferred
 Signal handling
 Thread pools
 Thread-specific data
 Scheduler activations

Operating System Concepts – 8th Edition 4.24 Silberschatz, Galvin and Gagne ©2009
 Semantics of fork() and exec()
 Does fork() duplicate only the calling thread or all threads?
 Both types are used on some UNIX systems. Some replicate all
threads, while others replicate only the thread that evokes the fork()
system call.
 If a thread wakes up the exec() system call, the program in the exec()
parameters replaces all processes (all threads).
 Which version to use depends on the application.
 If exec() is to be called immediately after the fork, then it is not
necessary to duplicate all threads because the program is replaced by
the parameters specified in exec(). In this case, only the calling thread is
replicated.
 However, if exec() is not called immediately after the fork, all processes
must be replicated.it is unnecessary

Operating System Concepts – 8th Edition 4.25 Silberschatz, Galvin and Gagne ©2009
 Thread Cancellation

 Terminating a thread before it has finished

 Two general approaches:
 Asynchronous cancellation terminates the target
thread immediately
 Deferred cancellation allows the target thread to
periodically check if it should be cancelled

Operating System Concepts – 8th Edition 4.26 Silberschatz, Galvin and Gagne ©2009
 Signal Handling

 Signals are used in UNIX systems to notify a process that a

particular event has occurred
 A signal handler is used to process signals
1. Signal is generated by particular event
2. Signal is delivered to a process
3. Signal is handled
 Options:
 Deliver the signal to the thread to which the signal applies
 Deliver the signal to every thread in the process
 Deliver the signal to certain threads in the process
 Assign a specific thread to receive all signals for the process

Operating System Concepts – 8th Edition 4.27 Silberschatz, Galvin and Gagne ©2009
 Thread Pools
 Create a number of threads in a pool where they await work
 Advantages:
 Usually slightly faster to service a request with an existing thread
than create a new thread
 Allows the number of threads in the application(s) to be bound to
the size of the pool

Operating System Concepts – 8th Edition 4.28 Silberschatz, Galvin and Gagne ©2009
 Thread Specific Data
 Allows each thread to have its own copy of data
 Useful when you do not have control over the thread creation
process (i.e., when using a thread pool)

Operating System Concepts – 8th Edition 4.29 Silberschatz, Galvin and Gagne ©2009
 Scheduler Activations
 Both M:M and Two-level models require communication to maintain
the appropriate number of kernel threads allocated to the application
 Scheduler activations provide upcalls - a communication mechanism
from the kernel to the thread library
 This communication allows an application to maintain the correct
number kernel threads

Operating System Concepts – 8th Edition 4.30 Silberschatz, Galvin and Gagne ©2009
 Operating System Examples
 Windows XP Threads
 Linux Thread

Operating System Concepts – 8th Edition 4.31 Silberschatz, Galvin and Gagne ©2009
 Windows XP Threads

 Implements the one-to-one mapping, kernel-level

 Each thread contains
 A thread id
 Register set
 Separate user and kernel stacks
 Private data storage area
 The register set, stacks, and private storage area are known
as the context of the threads
 The primary data structures of a thread include:
 ETHREAD (executive thread block)
 KTHREAD (kernel thread block)
 TEB (thread environment block)

Operating System Concepts – 8th Edition 4.32 Silberschatz, Galvin and Gagne ©2009
 Windows XP Threads

Operating System Concepts – 8th Edition 4.33 Silberschatz, Galvin and Gagne ©2009
 Linux Threads

 Linux refers to them as tasks rather than threads

 Thread creation is done through clone() system call

 clone() allows a child task to share the address space

of the parent task (process)

Operating System Concepts – 8th Edition 4.34 Silberschatz, Galvin and Gagne ©2009
 Linux Threads

Operating System Concepts – 8th Edition 4.35 Silberschatz, Galvin and Gagne ©2009
 End of Chapter 4

Operating System Concepts – 8th Edition, Silberschatz, Galvin and Gagne ©2009