GROUP MEMBERS

• SUMAIN SHAHID (131359)• HAMZA QAISER (131361)• M ZUBAIR (131362)

Multithreading

contents

• What is Thread ?• Advantage Of Threads • Difference b/w Threads And Process• Tread Control Block (TCB)• Types Of Threads • What is Multithreading ?• Multithreading Models

What is thread ?• Threads, Like Processes, Are a Mechanisms To Allow a Program to do

more than one thing at a time . As with processes , threads appear to run concurrently

• The Linux kernel schedules them asynchronously , interrupting each thread from time to time to give others a chance to execute. Conceptually , a thread exists within a process .

• Threads are a finer-grained unit of execution than processes . When you invoke a program

• Linux creates a new process and in that process creates a single thread ,

• which runs the program sequentially . That thread can create additional threads ;

• all these threads run the same program in the same process , but each thread may be executing a different part of the program at any given time

Advantages of Thread

• Thread minimize context switching time.• Use of threads provides concurrency within a process.• Efficient communication.• Economy- It is more economical to create and context

switch threads.• Utilization of multiprocessor architectures to a greater

scale and efficiency.

Difference between Process and ThreadS.N Process Thread

1 Process is heavy weight or resource intensive. Thread is light weight taking lesser resources than a process.

2 Process switching needs interaction with operating system.

Thread switching does not need to interact with operating system.

3 In multiple processing environments each process executes the same code but has its own memory and file resources.

All threads can share same set of open files, child processes.

4 If one process is blocked then no other process can execute until the first process is unblocked.

While one thread is blocked and waiting, second thread in the same task can run.

5 Multiple processes without using threads use more resources.

Multiple threaded processes use fewer resources.

6 In multiple processes each process operates independently of the others.

One thread can read, write or change another thread's data.

Thread control block (TCB)

• An operating system had to keep track of treads, and stored its per-thread information in a data structure called a thread control block (TCB). A multithread-aware operating system also needs to keep track of threads.

The items that the operating system must store that are unique to each thread are:

• Thread ID• Saved registers, stack pointer, instruction pointer• Stack (local variables, temporary variables, return addresses)• Signal mask• Priority (scheduling information)

The items that are shared among threads within a process are:• Text segment (instructions)• Data segment (static and global data)• BSS segment (uninitialized data)• Open file descriptors• Signals• Current working directory• User and group IDs

Types of Thread

Threads are implemented in following two ways• User Level Threads -- User managed threads• Kernel Level Threads-- Operating System managed

threads acting on kernel, an operating system core.

User Level Threads

• In this case, application manages thread management kernel is not aware of the existence of threads. The thread library contains code for creating and destroying threads, for passing message and data between threads, for scheduling thread execution and for saving and restoring thread contexts. The application begins with a single thread and begins running in that thread.

Advantages of user level thread

• Thread switching does not require Kernel mode privileges.• User level thread can run on any operating system.• Scheduling can be application specific in the user level thread.• User level threads are fast to create and manage.Disadvantages• In a typical operating system, most system calls are blocking.• Multithreaded application cannot take advantage of multiprocessing.

Kernel Level Threads

• In this case, thread management done by the Kernel. There is no thread management code in the application area. Kernel threads are supported directly by the operating system.

• The Kernel maintains context information for the process as a whole and for individuals threads within the process. Scheduling by the Kernel is done on a thread basis. The Kernel performs thread creation, scheduling and management in Kernel space. Kernel threads are generally slower to create and manage than the user threads.

Advantages

• Kernel can simultaneously schedule multiple threads from the same process on multiple processes.

• If one thread in a process is blocked, the Kernel can schedule another thread of the same process.

• Kernel routines themselves can multithreaded. Disadvantages• Kernel threads are generally slower to create and manage

than the user threads.• Transfer of control from one thread to another within same

process requires a mode switch to the Kernel.

What Is Multithreading ?• A process may be multithreaded, where the same program contains

multiple concurrent threads of execution. An operating system that supports multithreading has a scheduler that is responsible for preempting and scheduling all threads of all processes.

• Multithreading is a specialized form of multitasking and a multitasking is the feature that allows your computer to run two or more programs concurrently. In general, there are two types of multitasking: process-based and thread-based.

• Process-based multitasking handles the concurrent execution of programs. Thread-based multitasking deals with the concurrent execution of pieces of the same program.

• A multithreaded program contains two or more parts that can run concurrently. Each part of such a program is called a thread, and each thread defines a separate path of execution.

Why is this good ?

• Threads are more efficient – Much less overhead to create: no need to create new copy of memory space, file descriptors, etc.

• Sharing memory is easy (automatic) – No need to figure out inter-process communication mechanisms

• Take advantage of multiple CPUs – just like processes – • Program scales with increasing # of CPUs – Take advantage of multiple cores•

• Example of Multithreading• Consider a simple web server • The web server listens for request and serves it• If the web server was not multithreaded, the requests processing would be in a queue, thus

increasing the response time and also might hang the server if there was a bad request.• By implementing in a multithreaded environment, the web server can serve multiple request

simultaneously thus improving response time

Multithreading ModelsSome operating system provide a combined user level thread and Kernel level thread facility. Solaris is a good example of this combined approach. In a combined system, multiple threads within the same application can run in parallel on multiple processors and a blocking system call need not block the entire process. Multithreading models are three types• Many to many relationship.• Many to one relationship.• One to one relationship.

Many to Many Model

• In this model, many user level threads multiplexes to the Kernel thread of smaller or equal numbers. The number of Kernel threads may be specific to either a particular application or a particular machine.

• Following diagram shows the many to many model. In this model, developers can create as many user threads as necessary and the corresponding Kernel threads can run in parallels on a multiprocessor.

Many to One Model

• Many to one model maps many user level threads to one Kernel level thread. Thread management is done in user space. When thread makes a blocking system call, the entire process will be blocks. Only one thread can access the Kernel at a time , so multiple threads are unable to run in parallel on multiprocessors.

• If the user level thread libraries are implemented in the operating system in such a way that system does not support them then Kernel threads use the many to one relationship modes.

One to One Model

• There is one to one relationship of user level thread to the kernel level thread . This model provides more concurrency than the many to one model. It also another thread to run when a thread makes a blocking system call. It support multiple thread to execute in parallel on microprocessors.

• Disadvantage of this model is that creating user thread requires the corresponding Kernel thread. OS/2, windows NT and windows 2000 use one to one relationship model.

Multithreading in linux :

Creating Threads:

• There is following routine which we use to create a POSIX thread:

• Here, p thread _ create creates a new thread and makes it executable. This routine can be called any number of times from anywhere within your code. Here is the description of the parameters:

•

#include <pthread.h>pthread_create (thread, attr, start_routine, arg)

Parameter Description

Thread An opaque, unique identifier for the new thread returned by the subroutine.

Attr An opaque attribute object that may be used to set thread attributes. You can specify a thread attributes object, or NULL for the default values.

start_routineThe C++ routine that the thread will execute once it is created.

Arg A single argument that may be passed to start _ routine. It must be passed by reference as a pointer cast of type void. NULL may be used if no argument is to be passed.

• The maximum number of threads that may be created by a process is implementation dependent. Once created, threads are peers, and may create other threads. There is no implied hierarchy or dependency between threads.

• Terminating Threads:• There is following routine which we use to terminate a POSIX

thread:

• Here p thread _ exit is used to explicitly exit a thread. Typically, the p thread _ exit() routine is called after a thread has completed its work and is no longer required to exist.

• If main() finishes before the threads it has created, and exits with

p thread _ exit(), the other threads will continue to execute. Otherwise, they will be automatically terminated when main() finishes.

#include <pthread.h>pthread_exit (status)

Join or detach threads:

• There are following two routines which we can use to join or detach threads:

P thread _ join ( thread _id, status) P thread _ detach (thread _ id) • The p thread _ join() subroutine blocks the calling

thread until the specified thread_ id thread terminates. When a thread is created, one of its attributes defines whether it is joinable or detached. Only threads that are created as joinable can be joined. If a thread is created as detached, it can never be joined