​

​

Chapter 4: Threads

​

​

​

​

Chapter 4: Threads

• Overview
• Multithreading Models
• Thread Libraries
• Threading Issues

​

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.

​

A thread is a path of execution within a process. A process can contain multiple threads.

​

​

A thread is also known as lightweight process. The idea is to achieve parallelism by dividing a process into multiple threads.

​

​

For example, In a browser, multiple tabs can be different threads.

​

MS Word uses multiple threads: one thread to format the text,

another thread to process inputs, etc

​

​

The primary difference is that threads within the same process run in a shared memory space, while processes run in separate memory spaces.

​

​

​

​

​

Threads

​

​

​

​

Threads

Thread is a single sequence stream within a process.

​

​

Threads have same properties as of the process so they are called as light weight processes.

​

​

Threads are executed one after another but gives the illusion as if they are executing in parallel.

​

​

Each thread has different states. Each thread has  

1. A program counter  
2. A register set  
3. A stack space

​

Threads are not independent of each other as they share the code, data, OS resources etc.  

​

​

​

​

Threads

Similarity between Threads and Processes –  

​

• Only one thread or process is active at a time 

​

• Within process both execute sequential.

​

• Both can create children.

​

Differences between Threads and Processes – 

• Threads are not independent, processes are. 

​

• Threads are designed to assist each other, processes may or may not do it. 

Single and Multithreaded Processes

Need of Thread

​

• It takes far less time to create a new thread in an existing process than to create a new process.

​

​

• Threads can share the common data, they do not need to use Inter- Process communication.

​

​

• Context switching is faster when working with threads.

​

​

• It takes less time to terminate a thread than a process.

Benefits

• Responsiveness

A program may be allowed to continue running even if part of it is

blocked. Thus, increasing responsiveness to the user.�

• Resource Sharing

By default, threads share the memory (and resources) of the process to

which they belong. Thus, an application is allowed to have several

different threads of activity within the same address-space.

​

• Economy

Allocating memory and resources for process-creation is costly. Thus, it is

more economical to create and context-switch threads.�

• Scalability

In a multiprocessor architecture, threads may be running in parallel on

different processors. Thus, parallelism will be increased.

​

Types of Threads

​

In the operating system, there are two types of threads.

​

1. Kernel level thread.

​

• User-level thread.

​

User-level thread

• The operating system does not recognize the user-level thread.

​

• User threads can be easily implemented and it is implemented by the user.

​

• If a user performs a user-level thread blocking operation, the whole process is blocked.

​

• The kernel level thread does not know nothing about the user level thread.

​

• The kernel-level thread manages user-level threads as if they are single-threaded processes? examples: Java thread, POSIX threads, etc.

​

User-level thread

Advantages of User-level threads

1. It is faster and efficient.
2. Context switch time is shorter than the kernel-level threads.
3. It does not require modifications of the operating system.
4. The register, PC, stack, and mini thread control blocks are stored in the

address space of the user-level process.

5. It is The user threads can be easily implemented than the kernel thread.

6. Simple to create, switch, and synchronize threads without the

intervention of the process.

​

​

Disadvantages of User-level threads

1. User-level threads lack coordination between the thread and the kernel.

​

• If a thread causes a page fault, the entire process is blocked.

�

Kernel level thread

​

• The kernel thread recognizes the operating system.

• There is a thread control block and process control block in the system for each thread and process in the kernel-level thread.

• The kernel-level thread is implemented by the operating system.

​

• The kernel knows about all the threads and manages them.

​

• The kernel-level thread offers a system call to create and manage the threads from user-space.

​

• Context switch time is longer in the kernel thread.

Example: Window Solaris.

Advantages of Kernel-level threads

​

1. The kernel-level thread is fully aware of all threads.

​

• The scheduler may decide to spend more CPU time in the process of

threads being large numerical.

​

3.The kernel-level thread is good for those applications that block the

frequency.

​

​

Disadvantages of Kernel-level threads

​

1. The kernel thread manages and schedules all threads.

​

• The implementation of kernel threads is difficult than the user thread.

​

• The kernel-level thread is slower than user-level threads.

• Multicore systems putting pressure on programmers, challenges include

​

• Dividing activities

​

• Balance

​

• Data splitting

​

• Data dependency

​

• Testing and debugging

​

Multicore Programming

Concurrent Execution on a Single-core System

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

Difference between User-Level & Kernel-Level Thread

​

Multithreading Models

Multi threading-It is a process of multiple threads executes at same time.

​

Multithreading allows the application to divide its task into individual threads.

​

​

In multi-threads, the same process or task can be done by the number of threads, or we can say that there is more than one thread to perform the task in multithreading. With the use of multithreading, multitasking can be achieved.

​

​

Many operating systems support kernel thread and user thread in a combined way. Example of such system is Solaris.

​

Application-level multithreads runs on multiple processors controlled by Kernel.

​

Multithreading Models

Multithreading Models

Importance of Multithreading in Operating System

​

Multithreading facilitates concurrent execution of multiple program codes and these program codes are easily managed in Java program including its sequence of execution and it plays an important role in

​

• Improving Front end response to the users.

​

• Enhancing application performance.

​

• Effective utilization of Computer resources.

​

• Low maintenance cost.

​

• Faster completion of tasks due to parallel operation.

​

• Simplifying development process and increasing productivity.

​

Multithreading Models

The relationship between application threads and kernel threads can be categorized into:

​

​

1. Many-to-one model

​

• One-to-one model

​

• Many-to-many model.

Many to Many Model 

​

In this model, we have multiple user threads multiplex to same or lesser number of kernel level threads.

​

Number of kernel level threads are specific to the machine, advantage of this model is if a user thread is blocked we can schedule others user thread to other kernel thread.

​

​

Thus, System doesn’t block if a particular thread is blocked. 

​

This model provides the best accuracy on concurrency.

Many to Many Model 

Example:

Solaris prior to version 9

Windows NT/2000 with the ThreadFiber package

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 by the thread library. When thread makes a blocking system call, the entire process will be blocked.

​

​

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 the system does not support them, then the Kernel threads use the many-to-one relationship modes.

Many to One Model

​

Examples:

Solaris Green Threads

GNU Portable Threads

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 allows another thread to run when a thread makes a blocking system call.

​

​

It supports multiple threads to execute in parallel on microprocessors.

​

​

Disadvantage of this model is that creating user thread requires the corresponding Kernel thread.

​

​

One to One Model

​

Examples

Windows NT/XP/2000

Linux

Solaris 9 and later

Two-level Model

• Similar to M:M, except that it allows a user thread to be bound to kernel thread

​

• Examples
• IRIX
• HP-UX
• Tru64 UNIX
• Solaris 8 and earlier

Thread Libraries

• Thread library provides programmer with API for creating and managing threads.

​

• Two primary ways of implementing

​

• Library entirely in user space. All code and data structures for the library exist in a local function call in user space and not in a system call.

​

​

• Kernel-level library supported by the OS. In this case the code and data structures for the library exist in kernel space.

​

​

​

Thread Libraries

The main thread libraries which are used are

​

​

• POSIX threads − Pthreads, the threads extension of the POSIX standard, may be provided as either a user level or a kernel level library.

​

• 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).

​

• The Pthread program must always have a pthread.h header file.

​

​

Thread Libraries

​

• JAVA thread − The JAVA thread API allows threads to be created and managed directly as JAVA programs.

​

• Java threads are managed by the JVM.

​

• Typically implemented using the threads model provided by underlying OS.

​

• Java threads may be created by:�
• Extending Thread class.
• Implementing the Runnable interface.

​

Thread Libraries

​

• WIN 32 thread − The windows thread library is a kernel level library available on windows systems.

​

​

• Creation of thread in Win2 library is similar to pthread library.

​

​

• To create a thread using the Win32 library always include windows.h header file in the program.

​

​

​

• The Win32 thread library is a kernel-level library which means invoking the Win32 library function results in a system call.

​

​

​

Threading Issues

• Semantics of fork() and exec() system calls

​

• Thread cancellation of target thread
• Asynchronous or deferred

​

• Signal handling

​

• Thread pools

​

• Thread-specific data

​

Semantics of fork() and exec()

​

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

​

• One that duplication all threads- The child thread does not call exec() after Forking.

​

• Only the thread that invoked Fork() system call is duplicated-exec() is called immediately after Forking.

Thread Cancellation

• Terminating a thread before it has finished.

​

• Two general approaches:

​

• Asynchronous cancellation terminates the target thread

(a thread which we want to cancel is termed ) 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
1. Signal is generated by particular event.
2. Signal is delivered to a process.
3. 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.

​

Whenever the request arrives at the server, it invokes a thread from the pool and assigns it the request to be serviced.

The thread completes its service and return back to the pool and wait for the next request.

Thread Specific Data

• If allows each thread to have its own copy of data. So the specific data associated with the specific thread is referred to as thread-specific data.

​

• Useful when you do not have control over the thread creation process (i.e., when using a thread pool).