Chapter 5: Threads

1
Chapter 5 Threads

• Overview
• Multithreading Models
• Threading Issues
• Pthreads
• Solaris 2 Threads
• Windows 2000 Threads
• Linux Threads
• Java Threads

2
Thread vs. Process

• A thread lightweight process (LWP) is a basic
  unit of CPU utilization.
• It comprises a thread ID, a program counter, a
  register set, and a stack.
• A traditional (heavyweight) process has a single
  thread of control.
• If the process has multiple threads of control,
  it can do more than one task at a time.

3
Single and Multithreaded Processes
4
Motivation

• An application typically is implemented as a
  separate process with several threads of control.
• For example, a web browser might have one thread
  display images or text while another thread
  retrieves data from the network.
• It is more efficient for a process that contains
  multiple threads to serve the same purpose.
• This approach would multithread the web-server
  process.

5
Benefits

• 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.
• Resource Sharing Threads share the memory and
  the resources of the process to which they
  belong.
• Economy Allocating memory and resources for
  process creation is costly.
• Utilization of MP (multiprocessor) Architectures
  Each thread may be running in parallel on a
  different processor.

6
User Threads

• Thread management done by user-level threads
  library
• User-level threads are fast to create and manage.
• If the kernel is single-threaded, then any
  user-level thread performing a blocking system
  call will cause the entire process to block.
• Examples
• - POSIX Pthreads
• - Mach C-threads
• - Solaris UI-threads

7
Kernel Threads

• Supported by the Kernel The kernel performs
  thread creation, scheduling, and management in
  kernel space.
• Examples
• - Windows 95/98/NT/2000
• - Solaris
• - Tru64 UNIX
• - BeOS
• - OpenBSD
• - FreeBSD
• - Linux

8
Multithreading Models

• Many-to-One The many-to-one model maps many
  user-level threads to one kernel thread.
• One-to-One The one-to-one model maps each user
  thread to a kernel thread.
• Many-to-Many The many-to-many multiplexes many
  user-level threads to a smaller or equal number
  of kernel threads.

9
Many-to-One

• Many user-level threads mapped to single kernel
  thread.
• Used on systems that do not support kernel
  threads.

10
Many-to-One Model
11
One-to-One

• Each user-level thread maps to kernel thread.
• Examples
• - Windows 95/98/NT/2000
• - OS/2

12
One-to-one Model
13
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 2
• Windows NT/2000 with the ThreadFiber package

14
Many-to-Many Model
15
Multithreading Models - Conclusion

• Whereas the many-to-one model allows the
  developer to create as many user threads as she
  wishes, true concurrency is not gained because
  the kernel can schedule only one thread at a
  time.
• The one-to-one model allows for greater
  concurrency, but the developer has to be careful
  not to create too many threads within an
  application.
• The many-to-many model suffers from neither of
  these shortcomings Developer can create as many
  user threads as necessary, and the corresponding
  kernel threads can run in parallel on a
  multiprocessor. Also, when a thread performs a
  blocking system call, the kernel can schedule
  another thread for execution.

16
Threading Issues

• Semantics of fork() and exec() system calls Two
  versions of fork are one that duplicates all
  threads and another that duplicates only the
  thread that invoked the fork system call.
• Thread cancellation is the task of terminating a
  thread before it has completed.
• Two different scenarios are asynchronous
  cancellation and deferred cancellation.
• A thread checks if it should be cancelled at a
  point referred as cancellation point.
• Signal handling
• Thread pools
• Thread specific data is a copy of data owned by
  a thread.

17
Signal Handling

• A signal is used in UNIX systems to notify a
  process that a particular event has occurred.
• All signals follow the same pattern
• 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.
• A signal can be synchronous or asynchronous
• Synchronous signals are delivered to the same
  process.
• Asynchronous signal is generated by an external
  event.

18
Signal Handling

• Every signal may be handled by one of two
  possible handlers
• A default signal handler
• A user-defined signal handler
• The options exist for delivering signals to a
  multithreaded program
• 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.
• Windows 2000 uses asynchronous procedure calls
  (APCs) to emulate signals.

19
Thread Pools

• A multithread server has potential problems
• The time required includes thread creating and
  discarding.
• Unlimited threads could exhaust system resources.
• One solution to this issue is to use thread
  pools.
• A thread pool has a number of threads being
  created at process startup, where they sit and
  wait for work.
• The benefits of thread pools are
• It is usually faster to service a request with an
  existing thread.
• A thread pool limits the number of threads at any
  one point.

20
Thread-Specific Data

• A multithread server has potential problems
• The time required includes thread creating and
  discarding.
• Unlimited threads could exhaust system resources.
• One solution to this issue is to use thread
  pools.
• A thread pool has a number of threads being
  created at process startup, where they sit and
  wait for work.
• The benefits of thread pools are
• It is usually faster to service a request with an
  existing thread.
• A thread pool limits the number of threads at any
  one point.

21
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.
• Refer to the program shown in Figure 5.5.

22
Solaris 2 Threads

• Solaris 2 is a version of UNIX with support for
  threads at the kernel and user levels, SMP, and
  real-time scheduling.
• Solaris 2 implements the Pthread API and UI
  threads.
• Between user- and kernel-level threads are
  ligthweight processes (LWPs).
• Threads in a process multiplex to connect an LWP.
  An LWP corresponds a kernel thread.
• A (un)bound user-level thread is (not)
  permanently attached to an LWP.

23
Solaris 2 Threads
24
Solaris Process
25
Windows 2000 Threads

• Implements the one-to-one mapping.
• Each thread contains
• - a thread id
• - register set
• - separate user and kernel stacks
• - private data storage area

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

27
Java Threads

• Java threads may be created by
• Extending Thread class
• Implementing the Runnable interface
• Calling the start method for the new object does
  two things
• It allocates memory and initializes a new thread
  in the JVM.
• It calls the run method, making the thread
  eligible to be run by JVM.
• Java threads are managed by the JVM.

28
Java Thread States