Download Week_3 Operating system File

OPERATING SYSTEM CONCEPT
AND PRACTISE
THREADS
 A thread is a basic unit of CPU utilization; it
comprises a thread ID, a program counter, a
register set, and a stack.
 If a process has multiple threads of control, it
can perform more than one task at a time.
 In certain situations, a single application may
be required to perform several similar tasks.
 Threads also play a vital role in remote
procedure call (RPC) systems, RPC servers are
multithreaded.
Single and Multithreaded Processes
BENEFITS
 Responsiveness
 Resource Sharing
 Economy
 Utilization of MP Architectures
 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.
 Resource sharing: By default, threads share the
memory and the resources of the process to which they
belong. It allows an application to have several
different threads of activity within the same address
space.
 Economy: Allocating memory and resources for process
creation is costly, it is more economical to create and
context-switch threads.
 Utilization of multiprocessor architectures: The
benefits of multithreading can be greatly increased in a
multiprocessor architecture.
MULTITHREADING MODELS
• Support for threads may be provided either at
the user level, for user threads, or by the
kernel, for kernel threads.
• User threads are supported above the kernel.
• Kernel threads are supported and managed
directly by the operating system.
• There are three ways to establish link between
user threads and kernel threads
Many to one
One to many
Many to many
Many-to-One Model
 Many user-level threads mapped to single
kernel thread
 The entire process will block if a thread makes
a blocking system call
 Only one thread can access the kernel at a
time.
• Green threads—a thread library available for
Solaris
 GNU Portable threads.
One-to-One
 Each user-level thread maps to kernel thread.
 It allows multiple threads to run in parallel on
multiprocessors.
 Creating a user thread requires creating the
corresponding kernel thread.
 Examples
– Windows NT/XP/2000
– Linux
– Solaris 9 and later
Many-to-Many Model
 Multiplexes many user-level threads to a
smaller or equal number of kernel threads.
• When a thread performs a blocking system
call, the kernel can schedule another thread
for execution.
 Solaris prior to version 9
 Windows NT/2000 with the ThreadFiber
package
Two-level Model
THREAD LIBRARIES
 A thread library provides the programmer an
API for creating and managing threads.
 There are two primary ways of implementing
a thread library.
 To provide a library entirely in user space with no
kernel support.
Implement a kernel-level library supported directly
by the operating system.
 There are 3 main thread libraries in use:
POSIX Pthreads,
 Win32,
 Java 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)
 WIN32 Threads
Threads are created in the Win32 API using the
Create Thread ()function.
DWORD data type is an unsigned 32-bit integer
Threads are created in the Win32 API using the
CreateThread () function
 Java Threads

Java threads are managed by the JVM
Java threads may be created by:
Extending Thread class
Implementing the Runnable interface
THREADING ISSUES






Semantics of fork() and exec() system calls
Thread cancellation
Signal handling
Thread pools
Thread specific data
Scheduler activations
Fork() and exec()
 Does fork() duplicate only the calling thread or
all threads?
 Some UNIX systems have chosen to have two
versions of fork()
• If a thread invokes the exec () system call, the
program specified in the parameter to exec ()
will replace the entire process
Thread Cancellation
 Thread cancellation is the task of terminating
a thread before it has completed.
 A thread that is to be canceled is often
referred to as the 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
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
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
 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)
Scheduler Activations
 Both M:M 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 examples
 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)
 Windows XP
 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