Threads provide concurrency within a process by allowing parallel execution. A thread is a flow of execution that has its own program counter, registers, and stack. Threads share code and data segments with other threads in the same process. There are two types: user threads managed by a library and kernel threads managed by the operating system kernel. Kernel threads allow true parallelism but have more overhead than user threads. Multithreading models include many-to-one, one-to-one, and many-to-many depending on how user threads map to kernel threads. Threads improve performance over single-threaded processes and allow for scalability across multiple CPUs.

1. Threads

2. Introduction
• What is a Thread?
• 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, and a stack which contains
the execution history.
• A thread is a single sequence stream within in a process.
• Because threads have some of the properties of processes, they are
sometimes called lightweight processes.
• A thread shares with its peer threads few information like code segment, data
segment and open files.
• When one thread alters a code segment memory item, all other threads see
that.

3. Introduction ctd’
• Threads provide a way to improve application performance through
parallelism.
• The CPU switches rapidly back and forth among the threads giving illusion
that the threads are running in parallel.
• Threads represent a software approach to improving performance of
operating system by reducing the overhead thread is equivalent to a
classical process.
• Each thread belongs to exactly one process and no thread can exist outside
a process.
• Each thread represents a separate flow of control.
• Threads have been successfully used in implementing network servers and
web server.
• They also provide a suitable foundation for parallel execution of
applications on shared memory multiprocessors.

4. Introduction ctd’
• Like a traditional process i.e., process with one thread, a thread can be in
any of several states (Running, Blocked, Ready or Terminated).
• Each thread has its own stack since thread will generally call different
procedures and thus a different execution history. This is why thread needs
its own stack.
• An operating system that has thread facility, the basic unit of CPU
utilization is a thread.
• A thread has or consists of a program counter (PC), a register set, and a
stack space.
• Threads are not independent of one other like processes as a result threads
shares with other threads their code section, data section, OS resources
also known as task, such as open files and signals.

5. Single-threaded and a multithreaded process.

6. Processes Vs Threads
Threads operate in the same way as that of processes. Some of the similarities
and differences are:
Similarities
• Like processes, threads share CPU and only one thread active (running) at a
time.
• Like processes, threads within a process, execute sequentially.
• Like processes, thread can create children.
• And like process, if one thread is blocked, another thread can run.
Differences
• Unlike processes, threads are not independent of one another.
• Unlike processes, all threads can access every address in the task.
• Unlike processes, threads are designed to assist one another. Note that
processes might or might not assist one another because processes may
originate from different users.

7. Difference between Process and Thread

8. Advantages of Thread
• Threads minimize the context switching time.
• Use of threads provides concurrency within a process.
• Efficient communication.
• It is more economical to create and context switch threads.
• Threads allow utilization of multiprocessor architectures to a greater
scale and efficiency.

9. Why Threads?
• Following are some reasons why we use threads in designing operating systems.
A process with multiple threads makes a great server for example printer server.
Because threads can share common data, they do not need to use inter process
communication.
Because of the very nature, threads can take advantage of multiprocessors.
• Threads are cheap in the sense that
They only need a stack and storage for registers therefore, threads are cheap to
create.
Threads use very little resources of an operating system in which they are working.
That is, threads do not need new address space, global data, program code or
operating system resources.
Context switching are fast when working with threads. The reason is that we only
have to save and/or restore PC, SP and registers.

10. Types of Thread
• There are two types of threads :
i. User Threads
ii. Kernel Threads

11. User Level Threads
• In this case, the thread management kernel is not aware of the
existence of threads.
• These are user managed 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 starts with a single thread.

12. Advantages of User-level threads:
• The most obvious advantage of this technique is that a user-level threads package can
be implemented on an Operating System that does not support threads.
• User level threads are fast to create and manage.
• Simple Representation: Each thread is represented simply by a PC, registers, stack and
a small control block, all stored in the user process address space.
• Simple Management: This simply means that creating a thread, switching between
threads and synchronization between threads can all be done without intervention of
the kernel.
• Fast and Efficient: Thread switching is not much more expensive than a procedure call.
Disadvantages of user-level threads:
• There is a lack of coordination between threads and operating system kernel.
Therefore, process as whole gets one time slice irrespective of whether process has
one thread or 1000 threads within. It is up to each thread to relinquish control to
other threads.
• User-level threads require non-blocking systems call i.e., a multithreaded kernel.
Otherwise, entire process will blocked in the kernel, even if there are runnable
threads left in the processes. For example, if one thread causes a page fault, the
process blocks.

13. Kernel Level Threads
• In this case, thread management is done by the Kernel.
• There is no thread management code in the application area.
• Kernel threads are supported directly by the operating system.
• Any application can be programmed to be multithreaded.
• All of the threads within an application are supported within a single process.
• 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.

14. • Advantages of kernel-level threads:
• Because kernel has full knowledge of all threads, Scheduler may decide to
give more time to a process having large number of threads than process
having small number of threads.
• Kernel can simultaneously schedule multiple threads from the same process
on multiple processes.
• Kernel-level threads are especially good for applications that frequently block
- If one thread in a process is blocked, the Kernel can schedule another
thread of the same process.
• Disadvantages of kernel level threads:
• The kernel-level threads are slow and inefficient. For instance, threads
operations are hundreds of times slower than that of user-level threads.
• Since kernel must manage and schedule threads as well as processes. It
requires a full thread control block (TCB) for each thread to maintain
information about threads. As a result there is significant overhead and
increased in kernel complexity.

15. Difference between User-Level & Kernel-Level
Thread
S.N. User-Level Threads Kernel-Level Thread
1 User-level threads are faster to create
and manage.
Kernel-level threads are slower to create
and manage.
2 Implementation is by a thread library at
the user level.
Operating system supports creation of
Kernel threads.
3 User-level thread is generic and can run
on any operating system.
Kernel-level thread is specific to the
operating system.
4 Multi-threaded applications cannot take
advantage of multiprocessing.
Kernel routines themselves can be
multithreaded.

16. Multithreading Models
• Some operating system provide a combined user level thread and Kernel
level thread facility e.g. 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.
i. Many-To-One Model
ii. One-To-One Model
iii. Many-To-Many Model

17. Many-To-One Threading Model
• In the many-to-one model, many user-level threads are all mapped onto
a single kernel thread.
• Thread management is handled by the thread library in user space,
which is very efficient.
• However, if a blocking system call is made, then the entire process
blocks, even if the other user threads would otherwise be able to
continue.
• Because a single kernel thread can operate only on a single CPU, the
many-to-one model does not allow individual processes to be split
across multiple CPUs.
• Green threads for Solaris and GNU Portable Threads implement the
many-to-one model in the past, but few systems continue to do so
today.

18. Many-to-one threading model diagram

19. One-To-One Threading Model
• The one-to-one model creates a separate kernel thread to handle each
user thread.
• One-to-one model overcomes the problems listed above involving blocking
system calls and the splitting of processes across multiple CPUs.
• However the overhead of managing the one-to-one model is more
significant, involving more overhead and slowing down the system.
• Most implementations of this model place a limit on how many threads
can be created.
• Linux and Windows from 95 implement the one-to-one model for threads.

20. One-to-one threading model diagram

21. Many-To-Many Threading Model
• The many-to-many model multiplexes any number of user threads
onto an equal or smaller number of kernel threads, combining the
best features of the one-to-one and many-to-one models.
• Users have no restrictions on the number of threads created.
• Blocking kernel system calls do not block the entire process.
• Processes can be split across multiple processors.
• Individual processes may be allocated variable numbers of kernel
threads, depending on the number of CPUs present and other factors.

22. Many-To-Many Threading Model diagram

23. Thread Libraries
• Thread libraries provides programmers with API for creating and managing of
threads.
• Thread libraries may be implemented either in user space or in kernel space.
• The user space involves API functions implemented solely within user space, with no
kernel support.
• The kernel space involves system calls, and requires a kernel with thread library
support.
Application that Benefits from Threads
• A proxy server satisfying the requests for a number of computers on a LAN would be
benefited by a multi-threaded process. In general, any program that has to do more
than one task at a time could benefit from multitasking. For example, a program that
reads input, process it, and outputs could have three threads, one for each task.
Application that cannot Benefit from Threads
• Any sequential process that cannot be divided into parallel task will not benefit from
thread, as they would block until the previous one completes. For example, a
program that displays the time of the day would not benefit from multiple threads.

24. Benefits of Multithreading
• Responsiveness
• Resource sharing, hence allowing better utilization of resources -
Threads allow the sharing of a lot resources that cannot be shared in
process, for example, sharing code section, data section, Operating
System resources like open file etc.
• Economy. Creating and managing threads becomes easier.
• Scalability. One thread runs on one CPU. In Multithreaded processes,
threads can be distributed over a series of processors to scale.
• Context Switching is smooth. Context switching refers to the
procedure followed by CPU to change from one task to another.

25. Resources used in Thread
Creation and Process Creation
• When a new thread is created it shares its code section, data section and
operating system resources like open files with other threads.
• But it is allocated its own stack, register set and a program counter.
• The creation of a new process differs from that of a thread mainly in the fact
that all the shared resources of a thread are needed explicitly for each process.
• So though two processes may be running the same piece of code they need to
have their own copy of the code in the main memory to be able to run.
• Two processes also do not share other resources with each other.
• This makes the creation of a new process very costly compared to that of a
new thread.

26. Multithreading Issues
• Thread Cancellation - Thread cancellation means terminating a thread before it has
finished working - are no longer needed. There can be two approaches for this, one
is Asynchronous cancellation, which terminates the target thread immediately. The
other is 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. Now in when a Multithreaded process receives a signal, to which
thread it must be delivered?
• There are four major options: a) Deliver the signal to the thread to which the signal
applies, b) Deliver the signal to every thread in the process, c) Deliver the signal to
certain threads in the process, d) Assign a specific thread to receive all signals in a
process.
• fork() System Call - fork() is a system call executed in the kernel through which a
process creates a copy of itself. Now the problem in Multithreaded process is, if one
thread forks, will the entire process be copied or not? The answers included a0 its
system dependent, b) If the new process execs right away, there is no need to copy all
the other threads. If it doesn't, then the entire process should be copied, c) A: Many
versions of UNIX provide multiple versions of the fork call for this purpose.
• Security Issues because of extensive sharing of resources between multiple threads.