Figure 5'01

1
Threads
Chapter 4
1
2
Threads

• Overview
• Multithreading Models
• Threading Issues
• Pthreads
• Windows XP Threads
• Linux Threads
• Java Threads

3
Review

• Process is a program in execution that can be in
  a number of states
• New, running, waiting, ready, terminated
• Process creation
• fork() and exec() system calls
• Inter-process communications
• Shared memory, and message passing
• Client-server communication
• Socket, RPC, RMI

3
4
Threads

• A thread (a lightweight process) is a basic unit
  of CPU utilization.
• A thread has a single sequential flow of control.
• A thread is comprised of A thread ID, a program
  counter, a register set and a stack.
• A process is the execution environment in which
  threads run.
• (Recall previous definition of process program
  in execution).
• The process has the code section, data section,
  OS resources (e.g. open files and signals).
• Traditional processes have a single thread of
  control
• Multi-threaded processes have multiple threads of
  control
• The threads share the address space and resources
  of the process that owns them.

5
Single and Multithreaded Processes
Threads encapsulate concurrency Active
component Address spaces encapsulate protection
Passive part Keeps buggy program from trashing
the system
5
6
Processes vs. Threads
Which of the following belong to the process and
which to the thread?
Process Thread Process Process Thread Process Thre
ad Process Thread Thread
Program code local or temporary data global
data allocated resources execution
stack memory management info Program
counter Parent identification Thread
state Registers
7
Control Blocks

• The thread control block (TCB) contains
• Thread state, Program Counter, Registers
• PCB' everything else (e.g. process id, open
  files, etc.)
• The process control block (PCB) PCB' U TCB

8
Why use threads?

• Because threads have minimal internal state, it
  takes less time to create a thread than a process
  (10x speedup in UNIX).
• It takes less time to terminate a thread.
• It takes less time to switch to a different
  thread.
• A multi-threaded process is much cheaper than
  multiple (redundant) processes.

9
Examples of Using Threads

• Threads are useful for any application with
  multiple tasks that can be run with separate
  threads of control.
• A Word processor may have separate threads for
• User input
• Spell and grammar check
• displaying graphics
• document layout
• A web server may spawn a thread for each client
• Can serve clients concurrently with multiple
  threads.
• It takes less overhead to use multiple threads
  than to use multiple processes.

10
Examples of multithreaded programs
Examples of multithreaded programs

• Most modern OS kernels
• Internally concurrent because have to deal with
  concurrent requests by multiple users
• But no protection needed within kernel
• Database Servers
• Access to shared data by many concurrent users
• Also background utility processing must be done
• Parallel Programming (More than one physical CPU)
• Split program into multiple threads for
  parallelism. This is called Multiprocessing

11
Benefits

• Responsiveness
• Threads allow a program to continue running even
  if part is blocked.
• For example, a web browser can allow user input
  while loading an image.
• Resource Sharing
• Threads share memory and resources of the process
  to which they belong.
• Economy
• Allocating memory and resources to a process is
  costly.
• Threads are faster to create and faster to switch
  between.
• Utilization of Multiprocessor Architectures
• Threads can run in parallel on different
  processors.
• A single threaded process can run only on one
  processor no matter how many are available.

12
User Threads

• Thread management may be done at either the user
  level or the kernel (OS) level.
• User Threads
• Thread management done by user-level threads
  library
• The kernel is unaware that the process is
  multithreaded.
• Thread creation and scheduling is done in user
  space without kernel intervention.

13
User Threads

• Three primary thread libraries
• POSIX Pthreads
• Win32 threads
• Java threads

14
Kernel Level Threads

• Threads managed by the Operating System.
• Kernel does creation, scheduling and management
  of threads.
• user-level threads are mapped to kernel thread.
• Examples
• - Windows 95/98/NT/2000
• - OS/2
• - Solaris-2
• - Linux
• - Some flavors of UNIX

15
Many-to-One

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

15
16
States of User Threads and Processes

• What happens when a process or thread is blocked
  in a many-to-one case?
• Suppose process B has two user threads, of which
  thread 2 is running. The following conditions
  could occur
• Thread 2 makes an I/O or other system call
• The kernel puts process B into a blocked state.
• The thread data structure will still show thread
  2 in the running state.
• Thread 2 is not actually running. (The entire
  process is blocked).
• Process B exhausts its time slice
• The kernel puts process B into the ready state.
• Thread 2 still in running state (but not actually
  running!)
• Thread 2 needs action performed by Thread 1
• Thread 2 goes into blocked state.
• Thread 1 starts running.
• Process B remains in running state.

17
Properties of User Level Threads

• Pros
• Fast switch between threads (kernel is not
  needed).
• Can have multi-threaded process on a system that
  does not understand threads.
• Cheap to create and destroy threads.
• User has complete control over threads (e.g. can
  assign priorities, etc.)
• Cons
• System call from one thread blocks all threads in
  the same process (many-to-one mapping).
• Process cannot use multiple processors.
• Extra work for user.

18
User and Kernel Level Threads

• User level threads
• are implemented with user thread libraries.
• The kernel can be unaware of the threads.
• Kernel level threads
• Implemented by the Operating systems.

19
One-to-One

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

20
Pros and Cons of One-to-one Mapping

• Pros
• System call from a thread does not block other
  threads in the same process.
• One process can use multiple processors.
• Create/destroy/switch of threads is less
  expensive than for processes.
• Cons
• Create/destroy/switch of Kernel Level threads is
  more expensive than for user level threads.
• CPU scheduling algorithms are unfair Each
  thread is given the same time slice. Tasks with
  more threads are given more CPU time than those
  with fewer threads.

21
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

22
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

23
Summary

• A thread is a flow of control within a process
• A multithreaded process contains several
  different flows of control within the same
  address space
• User-level threads are threads visible to the
  programmer but unknown to the kernel
• A thread library typically manages user-level
  threads
• The OS kernel supports and manages kernel-level
  threads
• In general, user-level threads are faster to
  create and manage than kernel threads

23
CS433 Operating Systems
24
Summary (Cont)

• Three different models relate user and kernel
  threads
• Many-to-one model maps many user threads to a
  single kernel thread
• One-to-one model maps each user thread to a
  corresponding kernel thread
• Many-to-many model multiplexes many user threads
  to a smaller or equal number of kernel threads
• Multithreaded program introduce challenges for
  the programmer
• Semantics of fork and exec, thread cancellation,
  signal handling and thread-specific data
• Many modern operating systems provide kernel
  support for threads

24
CS433 Operating Systems
25
Pthreads

• Pthreads is the POSIX standard defining an API
  for thread creation and synchronization.
• It is a specification for thread behavior.
  Different operating systems may implement it in
  different ways.
• Pthreads are generally used in UNIX-based
  systems.
• Pthreads are considered user level threads.

26
Summation Problem

• Compute summation 01N
• N is a non-negative number provided as a
  command-line argument
• We want to create a new thread to compute the
  summation and print out the result in the main
  thread.

27
Pthread Summation Example

• include ltpthread.hgt
• include ltstdio.hgt
• int sum / this data is shared by the thread(s)
  /
• void runner(void param) / the thread function
  /
• int main(int argc, char argv)
• pthread_t tid / the thread identifier /
• pthread_attr_t attr / set of attributes for the
  thread /
• /some error checking here /
• / get the default attributes /
• pthread_attr_init(attr)
• / create the child thread /
• pthread_create(tid,attr,runner,argv1)
• / now wait for the child thread to exit /
• pthread_join(tid,NULL)
• printf("sum d\n",sum)

28
The thread function

• void runner(void param)
• int upper atoi(param)
• int i
• sum 0
• if (upper gt 0)
• for (i 1 i lt upper i)
• sum i
• pthread_exit(0)

29
Threading Issues

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

30
Semantics of fork() and exec()

• If one thread in a multi-threaded program calls
  fork( ), does the new process duplicate all
  threads or only the thread that made the call?
• It depends on the version of UNIX.
• Some UNIX versions have 2 versions of fork( )
• one that duplicates all threads and
• one that duplicates only one thread.
• What happens if exec( ) is called from a thread?
• The same as before--the entire process is
  replaced.
• If exec( ) is called immediately after fork( )
  then it is not necessary to duplicate all
  threads.

31
Thread Cancellation

• Thread cancellation is the task of terminating a
  thread before it is completed.
• The thread to be cancelled is called the target
  thread.
• Asynchronous cancellation One thread immediately
  terminates the target thread. This can cause
  problems
• Cancellation may occur while the thread is in the
  middle of updating shared data.
• The OS may not reclaim all resources from the
  cancelled thread.
• Deferred cancellation Target thread can
  periodically check to determine whether it should
  terminate
• This allows the target thread an opportunity to
  terminate itself in an orderly fashion.
• Threads are only terminated at cancellation
  points.

32
Signal Handling

• A signal in UNIX is used to notify a process that
  an event has occurred.
• A signal can be synchronous or asynchronous
• synchronous signals are usually attributable to
  execution of code
• E.g. illegal memory access and division by 0
• Asynchronous signals are not usually attributable
  to execution of code
• E.g. ctrl c
• Response to a signal
• A signal is generated by the occurrence of an
  event.
• The generated signal is delivered to a process.
• Once delivered the signal must be handled. It is
  handled one of two ways
• The default signal handler (in the kernel)
• A user-defined signal handler.

33
Signals and Threads

• Options for delivering signals to a
  multi-threaded process
• Deliver the signal to the thread to which the
  signal applies.
• E.g. a divide by zero generates a synchronous
  signal.
• Deliver the signal to every thread in the process
• E.g. when the user hits ltControlgt-C
• Deliver the signal to certain threads in the
  process.
• some threads can specify which signals they will
  accept and which they will block.
• Typically, the signal is delivered only to the
  first thread that is not blocking it.
• Assign a specific thread to receive all signals
  for the process (Solaris 2)
• A special thread gets the signals and then
  delivers them to the first thread not blocking
  the signal.

34
Thread Pools

• The problem with allowing a process (e.g. a
  multi-threading web server) to create as many
  threads as it wants
• It takes time to create a thread prior to
  handling a service request.
• Unlimited number of threads could exhaust system
  resources.
• Solution Thread pools.
• A thread pool contains a limited number of
  threads created at process startup.
• When the program needs a thread, it takes one
  from the pool.
• When the thread is done with its service, it is
  returned to the pool.
• If no thread is available, the program must wait
  for one to be returned to the pool.
• Benefits of thread pools
• Faster--the process doesn't have to create the
  threads each time.
• Limits the number of threads.

35
Thread specific data

• Threads share most of their data with other
  threads.
• A thread may need its own data for certain tasks.
  This is called thread-specific data.
• Example Transaction processing.
• Each transaction may be handled by a separate
  thread.
• Each transaction may have a unique ID.
• Most thread libraries provide support for
  thread-specific data.

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

37
Solaris 2 threads

• Solaris 2 uses an intermediate level of threads,
  called lightweight processes (LWPs), between the
  user level threads and the kernel level threads.
• Each LWP is attached to a kernel level thread.
• User threads are multiplexed among LWPs.
• Bound threads are permanently attached to an LWP.
  Only one thread is attached to that LWP.
• Unbound threads are not permanently attached to
  an LWP. These are multiplexed among the
  available LWPs.
• The PCB includes a linked list of LWPs associated
  with the process.

38
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)
• clone() allows a child task to share the address
  space of the parent task (process)
• A fork( ) command creates a separate process with
  a copy of the address space of the parent.

39
Java Threads

• Java threads are managed by the JVM
• Java threads may be created by
• Extending Thread class
• Implementing the Runnable interface