CHAPTER 4: THREADS

CHAPTER 4: THREADS
 Overview
 Multicore Programming
 Multithreading Models
 Thread Libraries
 Implicit Threading
 Threading Issues
 Operating System Examples
OBJECTIVES
 To introduce the notion of a thread—a
fundamental unit of CPU utilization that forms the
basis of multithreaded computer systems
 To discuss the APIs for the Pthreads, Windows,
and Java thread libraries
 To explore several strategies that provide implicit
threading
 To examine issues related to multithreaded
programming
 To cover operating system support for threads in
Windows and Linux
MOTIVATION

 Most modern applications are multithreaded

 Threads run within application
 Multiple tasks with the application can be implemented
by separate threads
 Update display
 Fetch data
 Spell checking
 Answer a network request
 Process creation is heavy-weight while thread creation
is light-weight
 Can simplify code, increase efficiency
 Kernels are generally multithreaded
BENEFITS

 Responsiveness – may allow continued execution if

part of process is blocked, especially important for
user interfaces
 Resource Sharing – threads share resources of
process, easier than shared memory or message
passing
 Economy – cheaper than process creation, thread
switching lower overhead than context switching
 Scalability – process can take advantage of
multiprocessor architectures
 MULTICORE PROGRAMMING

 Multicore or multiprocessor systems putting pressure on

programmers, challenges include:
 Dividing activities
 Balance
 Data splitting
 Data dependency
 Testing and debugging
 Parallelism implies a system can perform more than one
task simultaneously
 Concurrency supports more than one task making progress
 Single processor / core, scheduler providing concurrency
 MULTICORE PROGRAMMING (CONT.)

 Types of parallelism
 Data parallelism – distributes subsets of the same
data across multiple cores, same operation on each
 Task parallelism – distributing threads across
cores, each thread performing unique operation
 As # of threads grows, so does architectural
support for threading
 CPUs have cores as well as hardware threads
 Consider Oracle SPARC T4 with 8 cores, and 8
hardware threads per core
 CONCURRENCY VS. PARALLELISM
 Concurrent execution on single-core system:

 Parallelism on a multi-core system:

SINGLE AND MULTITHREADED PROCESSES
 USER THREADS AND KERNEL THREADS

 User threads - management done by user-level threads library

 Three primary thread libraries:
 POSIX Pthreads
 Windows threads
 Java threads
 Kernel threads - Supported by the Kernel
 Examples – virtually all general purpose operating systems, including:
 Windows
 Solaris
 Linux
 Tru64 UNIX
 Mac OS X
 MULTITHREADING MODELS

 Many-to-One

 One-to-One

 Many-to-Many
MANY-TO-ONE

 Many user-level threads mapped to

single kernel thread
 One thread blocking causes all to
block
 Multiple threads may not run in
parallel on muticore system because
only one may be in kernel at a time
 Few systems currently use this
model
 Examples:
 Solaris Green Threads
 GNU Portable Threads
ONE-TO-ONE
 Each user-level thread maps to kernel
thread
 Creating a user-level thread creates a
kernel thread
 More concurrency than many-to-one
 Number of threads per process sometimes
restricted due to overhead
 Examples
 Windows
 Linux
 Solaris 9 and later
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 with the
ThreadFiber package
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
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
PTHREADS

 May be provided either as user-level or kernel-

level
 A POSIX standard (IEEE 1003.1c) API for
thread creation and synchronization
 Specification, not implementation
 API specifies behavior of the thread library,
implementation is up to development of the
library
 Common in UNIX operating systems (Solaris,
Linux, Mac OS X)
PTHREADS EXAMPLE
PTHREADS
PthreadsEXAMPLE
Example (Cont.) (CONT.)
WINDOWS MULTITHREADED C PROGRAM
WINDOWS MULTITHREADED C PROGRAM (CONT.)
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
THREADING ISSUES

 Semantics of fork() and exec() system

calls
 Signal handling
 Synchronous and asynchronous
 Thread cancellation of target thread
 Asynchronous or deferred
 Thread-local storage
 Scheduler Activations
 SEMANTICS OF FORK() AND EXEC()

 Does fork()duplicate only the

calling thread or all threads?
 Some UNIXes have two versions of
fork
 exec() usually works as normal –
replace the running process
including all threads
 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 by one of two signal handlers:
1. default
2. user-defined
 Every signal has default handler that kernel
runs when handling signal
 User-defined signal handler can override default
 For single-threaded, signal delivered to process
 SIGNAL HANDLING (CONT.)

 Where should a signal be delivered

for multi-threaded?
 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
 THREAD CANCELLATION

 Terminating a thread before it has finished

 Thread to be canceled is target thread
 Two general approaches:
 Asynchronous cancellation terminates the
target thread immediately
 Deferred cancellation allows the target thread
to periodically check if it should be cancelled
 Pthread code to create and cancel a thread:
 THREAD CANCELLATION (CONT.)
 Invoking thread cancellation requests cancellation, but actual
cancellation depends on thread state

 If thread has cancellation disabled, cancellation remains

pending until thread enables it
 Default type is deferred
 Cancellation only occurs when thread reaches cancellation point
 I.e. pthread_testcancel()
 Then cleanup handler is invoked
 On Linux systems, thread cancellation is handled through
signals
THREAD-LOCAL STORAGE

 Thread-local storage (TLS) 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)
 Different from local variables
 Local variables visible only during single function
invocation
 TLS visible across function invocations
 Similar to static data
 TLS is unique to each thread
 SCHEDULER ACTIVATIONS
 Both M:M and Two-level models require
communication to maintain the appropriate
number of kernel threads allocated to the
application
 Typically use an intermediate data structure
between user and kernel threads – lightweight
process (LWP)
 Appears to be a virtual processor on which process
can schedule user thread to run
 Each LWP attached to kernel thread
 How many LWPs to create?
 Scheduler activations provide upcalls - a
communication mechanism from the kernel to the
upcall handler in the thread library
 This communication allows an application to
maintain the correct number kernel threads
 OPERATING SYSTEM EXAMPLES

 Windows Threads
 Linux Threads
WINDOWS THREADS

 Windows implements the Windows API – primary

API for Win 98, Win NT, Win 2000, Win XP, and
Win 7
 Implements the one-to-one mapping, kernel-level
 Each thread contains
 A thread id
 Register set representing state of processor
 Separate user and kernel stacks for when thread runs in
user mode or kernel mode
 Private data storage area used by run-time libraries and
dynamic link libraries (DLLs)
 The register set, stacks, and private storage area are
known as the context of the thread
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)
 Flags control behavior

 struct task_struct points to process data structures

(shared or unique)