Lecture 4: Threads

1
Lecture 4 Threads

• Operating System
• Fall 2006

2
Contents

• Overview Processes Threads
• Benefits of Threads
• Thread State and Operations
• User Thread and Kernel Thread
• Multithreading Models
• Threading Issues

3
Process

• Resource ownership
• process is allocated a virtual address space to
  hold the process image
• Process may be allocated control or ownership of
  resources, e.g. I/O and files
• Protection function by OS
• Scheduling/execution
• The execution of a process follows an execution
  path(trace) through one or more programs
• The execution of a process may be interleaved
  with other processes
• Execution state and a dispatching priority
• These two characteristics are treated
  independently by the operating system

4
Processes Threads

• Resource ownership Process or Task
• Scheduling/execution Thread or lightweight
  process

One process, one thread (MS-DOS)
One process, multiple threads (Java Runtime)
Multiple processes, multiple threads (W2K,
Solaris, Linux)
Multiple processes, one thread per process (Unix)
5
Processes Threads (cont.)

• In a multithreaded environment, the followings
  are associated with a process
• Address space to hold the process image
• Protected access to processors, other processes
  (IPC), files, and I/O resources (devices
  channels)
• Within a process, there may be one or more
  threads, each with the following
• A thread execution state (Running, Ready, etc)
• A saved context when not running a separate
  program counter
• An execution stack
• Some static storage for local variables for this
  thread
• Access to memory and resources of its process,
  shared with all other threads in that process
  (global variables)

6
Single Threaded and Multithreaded Process Models
7
Benefits of Threads

• 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 use.
• Resource Sharing
• Since threads within the same process share
  memory and files, they can communicate with each
  other without invoking the kernel

8
Benefits of Threads (cont.)

• Economy
• Takes less time to create a new thread than a
  process
• Less time to terminate a thread than a process
• Less time to switch between two threads within
  the same process
• Utilization of Multiprocessor Architectures
• Threads within the same process may be running in
  parallel on different processors

9
Uses of Threads in a Single-User Multiprocessing
System

• Foreground and background work
• For example, in a spreadsheet program, one thread
  could display menus and read user input, while
  another thread executes user commands and updates
  the spreadsheet.
• Asynchronous processing
• Asynchronous elements in the program can be
  implemented as threads. For example, as a
  protection against power failure, a word
  processor may write its buffer to disk once every
  minute. A thread can be created whose sole job is
  periodic backup and that schedules directly with
  the OS.
• Speed execution
• On a multiprocessor system, multiple threads from
  the same process may be able to execute
  simultaneously.
• Modular program structure
• Programs that involve a variety of activities or
  a variety of sources and destinations of input
  and output may be easier to design and implement
  using threads.

10
Thread States

• Running
• Ready
• Blocked
• Note Suspend is at process-level

11
Thread Operations

• Spawn create new thread
• Block when a thread needs to wait for an event,
  it will block
• Unblock when the event for which a thread is
  blocked occurs, the thread is moved to the ready
  queue.
• Finish when a thread completes, its register
  context and stack are deallocated.

12
Threads

• Suspending a process involves suspending all
  threads of the process since all threads share
  the same address space
• Termination of a process, terminates all threads
  within the process

13
Question?

• If one thread in a process is blocked, does this
  prevent other threads in the process even if that
  other thread is in a ready state?

14
Answer

• Depends on whether OS is involved when the thread
  is blocked. If OS is involved, then answer is
  yes.

15
Thread Synchronization

• All of the threads of a process share the same
  address space and other resources such as open
  files. Any alternation of a resource by one
  thread affects the environment of the other
  threads in the same process. It is therefore
  necessary to synchronize the activities of the
  various threads.
• Will be covered later.

16
User Thread and Kernel Thread
17
User Threads

• All of the work of thread management is done by
  the application.
• The kernel is not aware of the existence of
  threads
• An application can be programmed to be
  multi-threaded by using a threads library, which
  is a package of routines for user thread
  management.
• The thread library contains code for creating and
  destroying threads, for passing messages and data
  between threads, for scheduling thread execution
  and for saving and restoring thread contexts.
• Three primary thread libraries
• POSIX Pthreads
• Win32 threads
• Java threads

18
Pure User Threads

• Advantages
• Thread switching does not require user/kernel
  mode switching.
• Thread scheduling can be application specific.
• User Threads can run on any OS through a thread
  library.
• Disadvantages
• When a ULT executes a system call, not only the
  thread is blocked, but all of the threads within
  the process are blocked.
• Multithreaded application cannot take advantage
  of multiprocessing since kernel assign one
  process to only one processor at a time.

19
Kernel Threads

• Supported and managed directly by the OS.
• W2K, Linux, and OS/2 are examples of this
  approach
• In a pure Kernel Thread facility, all of the work
  of thread management is done by the kernel. There
  is no thread management code in the application
  area, simply an application programming interface
  to the kernel thread facility.

20
Pure Kernel Threads

• Advantages
• Kernel can simultaneously schedule multiple
  threads from the same process on multiple
  processors
• If one thread in a process is blocked, kernel can
  schedule another thread of the same process
• Disadvantage
• More overhead

21
Multithreading Models

• Many-to-One
• One-to-One
• Many-to-Many

22
Many-to-One

• Many user-level threads mapped to single kernel
  thread
• Examples
• Solaris Green Threads
• GNU Portable Threads

23
One-to-One

• Each user-level thread maps to kernel thread
• Examples
• Windows NT/XP/2000
• Linux
• Solaris 9 and later

24
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

25
Two-level Model

• Similar to MM, except that it allows a user
  thread to be bound to kernel thread
• Examples
• IRIX
• HP-UX
• Tru64 UNIX
• Solaris 8 and earlier

26
Threading Issues

• Semantics of fork() and exec() system calls
• Thread cancellation
• Signal handling
• Thread pools
• Thread specific data
• Scheduler activations

27
Semantics of fork() and exec()

• Does fork() duplicate only the calling thread or
  all threads?

28
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

29
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
• Signal is generated by particular event
• Signal is delivered to a process
• 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

30
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

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

32
Scheduler Activations

• Both MM 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

33
End of lecture 4
Thank you!