Chapter 4: Threads

Chapter 4: Threads
Chapter 4: Threads
 Overview
 Multithreading Models
 Threading Issues
 Pthreads
 Windows XP Threads
 Linux Threads
 Java Threads
Operating System Concepts 4.2 Silberschatz, Galvin and Gagne

Single and Multithreaded
Processes

Benefits
 Responsiveness
 Resource Sharing
 Economy
 Utilization of MP Architectures

User Threads
 Thread management done by user-level threads

library
 Three primary thread libraries:

 POSIX Pthreads
 Win32 threads
 Java threads

Kernel Threads
 Supported by the Kernel
 Examples
 Windows XP/2000
 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
 Examples:
 Solaris Green Threads
 GNU Portable Threads

Many-to-One Model

One-to-One
 Each user-level thread maps to kernel thread

 Examples
 Windows NT/XP/2000
 Linux
 Solaris 9 and later

One-to-one Model

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

Many-to-Many Model

Thread libraries
 A thread library provides the programmer an Application
Programming Interface (API) for creating and managing threads.
 There are 2 primary ways of implementing a thread library.
 Provide a library entirely in user space with no kernel support.

All code & data structures for the library exist in user space.
Now the invoked call will be LOCAL CALL, not a System Call.
 Provide KERNEL level library supported directly by the OS.
Now its SYSTEM CALL.
 The main thread libraries are:
 POSIX Pthreads (User or Kernel Level Library)

 Win32 (Kernel Level Library)
 Java (Kernel Level Library)

Two-level Model

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

 Thread cancellation
 Signal handling
 Thread pools
 Thread specific data
 Scheduler activations

Semantics of fork() and exec()
 The fork() system call is used to create a separate,
duplicate process.
 If one thread in a program calls fork(), then
 In some UNIX systems they have 2 versions of fork().

 One which duplicates all the threads
 Other one that duplicates only the thread that invoked the
fork() call.
 If a thread invokes exec() system call, the program
specified in the parameter to exec() will replace the

entire process.

Thread Cancellation
 Task of 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.

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. A Signal is generated by the occurrence of a particular event.
2. A generated signal is delivered to a process.
3. Once delivered, the signal must be handled.
 Every signal may be handled by 2 possible handlers:
 A default signal handler
 A user-defined signal handler (more priority)
 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

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

Thread Specific Data
 Threads belonging to a process share the data of the

process.
 Each thread may need its own copy of certain data and
such data is referred as “Thread Specific Data”.
 Useful when we do not have control over the thread
creation process (i.e., when using a thread pool)

Scheduler Activations
 Both Many-to-Many 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

Pthreads
 A POSIX standard (IEEE 1003.1c) API for

thread creation and synchronization
 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)

Windows XP Threads
 Implements the one-to-one mapping

 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)

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)

Java Threads
 Java threads are managed by the JVM
 Java threads may be created by:
 Extending Thread class

 Implementing the Runnable interface

Java Thread States

End of Chapter 4

Chapter 4: Threads

Uploaded by

Copyright:

Available Formats

Chapter 4: Threads

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Chapter 4: Threads

Uploaded by

Copyright:

Available Formats

Chapter 4: Threads

Operating System Concepts 4.2 Silberschatz, Galvin and Gagne

Operating System Concepts 4.3 Silberschatz, Galvin and Gagne

Operating System Concepts 4.4 Silberschatz, Galvin and Gagne

 Thread management done by user-level threads

 Three primary thread libraries:

Operating System Concepts 4.5 Silberschatz, Galvin and Gagne

 Supported by the Kernel

Operating System Concepts 4.6 Silberschatz, Galvin and Gagne

Operating System Concepts 4.7 Silberschatz, Galvin and Gagne

 Many user-level threads mapped to single kernel

Operating System Concepts 4.8 Silberschatz, Galvin and Gagne

Operating System Concepts 4.9 Silberschatz, Galvin and Gagne

 Each user-level thread maps to kernel thread

Operating System Concepts 4.10 Silberschatz, Galvin and Gagne

Operating System Concepts 4.11 Silberschatz, Galvin and Gagne

 Allows many user level threads to be mapped to

Operating System Concepts 4.12 Silberschatz, Galvin and Gagne

Operating System Concepts 4.13 Silberschatz, Galvin and Gagne

 Provide a library entirely in user space with no kernel support.

 POSIX Pthreads (User or Kernel Level Library)

Operating System Concepts 4.14 Silberschatz, Galvin and Gagne

Operating System Concepts 4.15 Silberschatz, Galvin and Gagne

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

Operating System Concepts 4.16 Silberschatz, Galvin and Gagne

 The fork() system call is used to create a separate,

 If one thread in a program calls fork(), then

 In some UNIX systems they have 2 versions of fork().

 If a thread invokes exec() system call, the program

specified in the parameter to exec() will replace the

Operating System Concepts 4.17 Silberschatz, Galvin and Gagne

 Task of terminating a thread before it has finished.

 Two general approaches:

 Asynchronous cancellation terminates the target thread

 Deferred cancellation allows the target thread to

Operating System Concepts 4.18 Silberschatz, Galvin and Gagne

Operating System Concepts 4.19 Silberschatz, Galvin and Gagne

 Create a number of threads in a pool where they await

 Usually slightly faster to service a request with an

 Allows the number of threads in the application(s) to be

Operating System Concepts 4.20 Silberschatz, Galvin and Gagne

 Threads belonging to a process share the data of the

Operating System Concepts 4.21 Silberschatz, Galvin and Gagne

 Both Many-to-Many 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 4.22 Silberschatz, Galvin and Gagne

 A POSIX standard (IEEE 1003.1c) API for

Operating System Concepts 4.23 Silberschatz, Galvin and Gagne

 Implements the one-to-one mapping

Operating System Concepts 4.24 Silberschatz, Galvin and Gagne

 Linux refers to them as tasks rather than

Operating System Concepts 4.25 Silberschatz, Galvin and Gagne

 Java threads are managed by the JVM