Threads are using in operating systems.pptx

Silberschatz, Galvin and Gagne ©2009
Operating System Concepts – 8th Edition,
Chapter 4: Threads
Changes by MA Doman 2013

4.2 Silberschatz, Galvin and Gagne ©2009
Operating System Concepts – 8th Edition
Chapter 4: Threads
 Overview
 Multithreading Models
 Thread Libraries
 Threading Issues
 Operating System Examples
 Windows XP Threads
 Linux Threads

Objectives
 To introduce the notion of a thread — a fundamental unit of CPU utilization
that forms the basis of multithreaded computer systems
 To discuss the APIs for the Pthreads, Win32, and Java thread libraries
 To examine issues related to multithreaded programming

Thread Overview
 Threads are mechanisms that permit an application to perform multiple
tasks concurrently.
 A web browser might have one thread display images or text while another
thread retrieves data from the network, for example. A word processor may
have a thread for displaying graphics, another thread for responding to
keystrokes from the user, and a third thread for performing spelling and
grammar checking in the background.

Thread Overview
 Threads are mechanisms that permit an application to perform multiple
tasks concurrently.
 Thread is a basic unit of CPU utilization. A thread is a flow of execution
through the process code, with its own program counter that keeps track of
which instruction to execute next, system registers which hold its current
working variables.
 Thread ID
 Program counter
 Register set
 Stack
 A single program can contain multiple threads
 Threads share with other threads belonging to the same process
 Code, data, open files…….

Single and Multithreaded Processes
Traditional (heavyweight)
process has a single thread
of control
heavyweight process lightweight process

Threads in Memory
Memory is allocated for a process in segments or parts:
0000000
Increasing
virtual
address
Text ( program code)
Initialized data
Un-initialized data
Heap
Stack for main thread
argv, environment
Stack for thread 2
Stack for thread 3
Stack for thread 1
Main thread executing here
Thread 1 executing here

Benefits
 Responsiveness
Interactive application can delegate background functions to a thread and keep
running. 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
Several different threads can access the same address space. Threads share
the memory and the resources of the process to which they belong by default.
 Economy
Allocating memory and new processes is costly. Threads are much ‘cheaper’ to
initiate. In Solaris, for example, creating a process is about thirty times slower
than is creating a thread, and context switching is about five times slower.
 Scalability
Use threads to take advantage of multiprocessor architecture. where threads
may be running in parallel on different processing cores. A single-threaded
process can run on only one processor, regardless how many are available

Multithreaded Server Architecture
 In certain situations, a single application may be required to perform several
similar tasks. For example, a web server accepts client requests for web
pages, images, sound, and so forth. A busy web server may have
several(perhaps thousands of) clients concurrently accessing it.
 Solution?
 One solution is to have the server run as a single process that accepts
requests. When the server receives a request, it creates a separate process
to service that request. In fact, this process-creation method was in
common use before threads became popular. Process creation is time
consuming and resource intensive, however.
 It is generally more efficient to use one process that contains multiple
threads. If the web-server process is multithreaded, the server will create a
separate thread that listens for client requests. When a request is made,
rather than creating another process, the server creates a new thread to
service the request and resume listening for additional requests.

Multithreaded Server Architecture
thread
thread
thread
thread

Concurrent Execution on a Single-core System
Multicore Programming
Parallel Execution on a Multicore System

Parallel vs Concurrent
 A system is parallel if it can perform more than one task simultaneously.
 In contrast, a concurrent system supports more than one task by allowing all
the tasks to make progress. Thus, it is possible to have concurrency without
parallelism.

Multicore Programming
 Multicore systems putting pressure on programmers, challenges include
 Dividing activities
 What tasks can be separated to run on different processors
 Balance
 Balance work on all processors
 Data splitting
 Separate data to run with the tasks
 Data dependency
 Watch for dependences between tasks
 Testing and debugging
 Harder!!!!

Multithreading Models
 Support provided at either
 User level -> user threads
Supported above the kernel and managed without kernel support
They are created and managed by users. They are used at the application
level. There is no involvement of the OS. A good example is when we use
threading in programming like in Java, C#, Python, etc, we use user
threads.

 Kernel level -> kernel threads
Supported and managed directly by the operating system. All modern
OSes support kernel level threads, allowing the kernel to perform multiple
simultaneous tasks and/or to service multiple kernel system calls
simultaneously.

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

 Some operating system provide a combined user level thread and Kernel
level thread facility. Solaris is a good example of this combined approach.
In a specific implementation, the user threads must be mapped to kernel
threads, using one of the following strategies.
 Many-to-One
 One-to-One
 Many-to-Many
User Thread – to - Kernel Thread

Many-to-One
Many user-level
threads mapped to
single kernel thread

Many to one
 The many-to-one model maps many user-level threads
to one kernel thread. Thread management is done by the
thread library in user space, so it is efficient . However,
the entire process will block if a thread makes a blocking
system call. Also, because only one thread can access
the kernel at a time, multiple threads are unable to run in
parallel on multicore systems
 However, very few systems continue to use the model
because of its inability to take advantage of multiple
processing cores.

One-to-One
Each user-level thread maps to kernel thread
 Examples
 Windows NT/XP/2000
 Linux

One-to-one
 The one-to-one model maps each user thread to a
kernel thread. It provides more concurrency than the
many-to-one model by allowing another thread to run
when a thread makes a blocking system call.
 It also allows multiple threads to run in parallel on
multiprocessors.
 The only drawback to this model is that creating a user
thread requires creating the corresponding kernel thread.
Because the overhead of creating kernel threads can
burden the performance of an application, most
implementations of this model restrict the number of
threads supported by the system

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
 Example
 Windows NT/2000
with the ThreadFiber
package

Thread Libraries
 Thread library provides programmer with API for creating and managing
threads
 Two primary ways of implementing
 Library entirely in user space
 Kernel-level library supported by the OS. Invoking a function in the API
for the library typically results in a system call to the kernel.
 Three main thread libraries in use today:
 POSIX Pthreads
 Win32
 Java

Thread Libraries
 Three main thread libraries in use today:
 POSIX Pthreads
 May be provided either as user-level or kernel-level
 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
 Win32
 Kernel-level library on Windows system
 Java
 Java threads are managed by the JVM
 Typically implemented using the threads model provided by
underlying OS

POSIX: Thread Creation
#include <pthread.h>
pthread_create (thread, attr, start_routine, arg)
returns : 0 on success, some error code on failure.

POSIX: Thread Termination
#include <pthread.h>
Void pthread_exit (return_value)

Thread Cancellation
Terminating a thread before it has finished
Having made the cancellation request, pthread_cancel() returns
immediately; that is it does not wait for the target thread to
terminate.
So, what happens to the target thread?
What happens and when it happens depends on the thread’s
cancellation state and type.

Thread Cancellation
Thread attributes that indicate cancellation state and type
 Two general states
 Thread can not be cancelled.
 PTHREAD_CANCEL_DISABLE
 Thread can be cancelled
 PTHREAD_CANCEL_ENABLE
 Default

Thread Cancellation
 When thread is cancelable, there are two general types
 Asynchronous cancellation terminates the target
thread immediately
 PTHREAD_CANCEL_ASYNCHRONOUS
 Deferred cancellation allows the target thread to
periodically check if it should be cancelled
 PTHREAD_CANCEL_DEFERRED
 Cancel when thread reaches ‘cancellation point’

Semantics of fork() ,exec(), exit()
Does fork() duplicate only the calling thread or all threads?
 If one thread in a program calls fork(), does the new process duplicate all
threads, or is the new process single-threaded? Some UNIX systems have
chosen to have two versions of fork(), one that duplicates all threads and
another that duplicates only the thread that invoked the fork() system call.
 Threads and exec()
 With exec(), the calling program is replaced in memory That is, if a thread
invokes the exec() system call, the program specified in the parameter to
exec() will replace the entire process—including all threads.
 Threads and exit()
If any thread calls exit() or the main thread does a return, ALL threads
immediately vanish. No thread-specific data destructors or cleanup
handlers are executed.

Threads are using in operating systems.pptx

Recommended

Recommended

More Related Content

Similar to Threads are using in operating systems.pptx

Similar to Threads are using in operating systems.pptx (20)

Recently uploaded

Recently uploaded (20)

Threads are using in operating systems.pptx