INTRODUCTION TO THREADS

AND CONCURRENCY

User Mode vs Kernel Mode

There are two modes of operation in the operating system to make sure it
works correctly. These are user mode and kernel mode.
They are explained as follows −
User Mode
The system is in user mode when the operating system is running a user
application such as handling a text editor. The transition from user mode to
kernel mode occurs when the application requests the help of operating
system or an interrupt or a system call occurs.
The mode bit is set to 1 in the user mode. It is changed from 1 to 0 when
switching from user mode to kernel mode.
Kernel Mode
The system starts in kernel mode when it boots and after the operating system
is loaded, it executes applications in user mode. There are some privileged
instructions that can only be executed in kernel mode.
These are interrupt instructions, input output management etc. If the
privileged instructions are executed in user mode, it is illegal and a trap is
generated.
The mode bit is set to 0 in the kernel mode. It is changed from 0 to 1 when
switching from kernel mode to user mode.
An image that illustrates the transition from user mode to kernel mode and
back again is –
In the above image, the user process executes in the user mode until it gets a
system call. Then a system trap is generated and the mode bit is set to zero.
The system call gets executed in kernel mode. After the execution is completed,
again a system trap is generated and the mode bit is set to 1. The system
control returns to kernel mode and the process execution continues.
Necessity of Dual Mode (User Mode and Kernel Mode) in Operating System
The lack of a dual mode i.e user mode and kernel mode in an operating system
can cause serious problems. Some of these are −
 A running user program can accidentaly wipe out the operating system
by overwriting it with user data.
 Multiple processes can write in the same system at the same time, with
disastrous results.
These problems could have occurred in the MS-DOS operating system which
had no mode bit and so no dual mode.
Difference Between Kernel Mode and User mode

Criteria Kernel Mode User Mode

Access to Resources In kernel mode, the In user mode, the

program has direct and application program do
Criteria Kernel Mode User Mode

not have direct access

to system resources. In
unrestricted access to
order to access the
system resources.
resources, a system call
must be made.

In Kernel mode, the

In user mode, a single
whole operating
Interruptions process fails if an
system might go down
interrupt occurs.
if an interrupt occurs

User mode is also

Kernel mode is also
known as the
known as the master
Modes unprivileged mode,
mode, privileged
restricted mode, or
mode, or system mode.
slave mode.

In kernel mode, all

In user mode, all
processes share a
Virtual address space processes get separate
single virtual address
virtual address space.
space.

In kernel mode, the

While in user mode the
applications have more
Level of privilege applications have fewer
privileges as compared
privileges.
to user mode.

Restrictions As kernel mode can While user mode needs

access both the user to access kernel
programs as well as the programs as it cannot
Criteria Kernel Mode User Mode

kernel programs there

directly access them.
are no restrictions.

The mode bit of kernel- While the mode bit of

Mode bit value
mode is 0. user-mode is 1.

It can only make

It is capable of
references to memory
Memory References referencing both
allocated for user
memory areas.
mode.

A system crash in
In user mode, a system
kernel mode is severe
crash can be recovered
System Crash and makes things more
by simply resuming the
complicated.
session.

Only essential User programs can

functionality is access and execute in
Access
permitted to operate in this mode for a given
this mode. system.

Functionality The kernel mode can The user mode is a

refer to any memory standard and typical
block in the system and viewing mode, which
can also direct the CPU implies that
for the execution of an information cannot be
instruction, making it a executed on its own or
very potent and reference any memory
significant mode. block; it needs
Criteria Kernel Mode User Mode

an Application Protocol
Interface (API) to
achieve these things.

Conclusion
User mode and kernel mode play critical roles in system balance and safety.
User mode restricts software to access to system sources to prevent accidental
or malicious interference, while kernel mode grants the operating
system unrestricted access to hardware and essential features, making sure
clean and secure operation.

THREADS :
Thread is the segment of a process which means a process can have multiple
threads and these multiple threads are contained within a process. A thread
has three states: Running, Ready, and Blocked. The thread takes less time to
terminate as compared to the process but unlike the process, threads do not
isolate.
Significance of Thread
o Creation of a new thread within an existing process is more time-efficient
than the creation of a new process.
o Threads have the ability to share common data without the need for
explicit communication.
o Context switching is faster when working with threads.
o Terminating a thread takes less time compared to terminating a process.
Difference Between Process and Thread
The table below represents the difference between process and thread.

Process Thread

Process means a program in

Thread means a segment of a process.
execution.

A process takes more time to

A thread takes less time to terminate.
terminate.
Process Thread

It takes more time for

It takes less time for creation.
creation.

It also takes more time for

It takes less time for context switching.
context switching.

A process is less efficient in Thread is more efficient in terms of

terms of communication. communication.

We don’t need multi programs in action for

Multiprogramming holds the
multiple threads because a single process
concepts of multi-process.
consists of multiple threads.

Every process runs in its own

Threads share memory.
memory.

A process is heavyweight A Thread is lightweight as each thread in a

compared to a thread. process shares code, data, and resources.

Process switching uses an

Thread switching may not require calling
interface in an operating
involvement of operating system.
system.

If one process is blocked,

If a user-level thread is blocked, then all
then it will not affect the
other user-level threads are blocked.
execution of other processes.

A process has its own Process Thread has Parents’ PCB, its own Thread
Process Thread

Control Block, Stack, and Control Block, and Stack and common
Address Space. Address space.

Since all threads of the same process share

Changes to the parent address space and other resources so any
process do not affect child changes to the main thread may affect the
processes. behavior of the other threads of the
process.

No system call is involved, it is created using

A system call is involved in it.
APIs.

A process does not share

Threads share data with each other.
data with each other.

Note: In some cases where the thread is processing a bigger workload

compared to a process’s workload then the thread may take more time to
terminate. But this is an extremely rare situation and has fewer chances to
occur.
Advantages of Process
 Processes work independently in their own memory, ensuring no
interference and better security.
 Resources like CPU and memory are allocated effectively to optimize
performance.
 Processes can be prioritized to ensure important tasks get the resources
they need.
Disadvantages of Process
 Frequent switching between processes can slow down the system and
reduce speed.
  Improper resource management can cause deadlocks where processes
stop working and block progress.
 Having too many processes can make the process table take up a lot of
memory. This can also make searching or updating the table slower,
which can reduce system performance.
Advantages of Thread
 When there is a lot of computing and input/output (I/O) work, threads
help tasks run at the same time, making the app faster.
 Another advantage for having threads is that since they are lighter
weight than processes, they are easier (i.e., faster) to create and destroy
than processes.
 Many apps need to handle different tasks at the same time. For example,
a web browser can load a webpage, play a video, and let you scroll all at
once. Threads make this possible by dividing these tasks into smaller
parts that can run together.
Disadvantages of Thread
 Threads in the same process are not completely independent like
separate processes. They share the same memory space including global
variables. This means one thread can accidentally change or even erase
another thread’s data as there is no protection between them.
 Threads also share resources like files. For example – if one thread closes
a file while another is still using it, it can cause errors or unexpected
behavior.
 If too many threads are created they can slow down the system or cause
it to run out of memory.
Conclusion
From the above discussion we can conclude that the process is program under
execution that takes more time in creation as well as termination whereas
threads are component of process that takes less time in creation as well as
termination. Process has PCB whereas threads have their own thread PCB
along with the PCB of parent process.
Difference between User Level thread and Kernel Level
thread
User-level threads are threads that are managed entirely by the user-level
thread library, without any direct intervention from the operating system’s
kernel, whereas, Kernel-level threads are threads that are managed directly by
the operating system’s kernel.
User-Level Thread
The User-level Threads are implemented by the user-level software. These
threads are created and managed by the thread library, which the operating
system provides as an API for creating, managing, and synchronizing threads. it
is faster than the kernel-level threads, it is basically represented by the
program counter, stack, register, and PCB.
User-level threads are typically employed in scenarios where fine control over
threading is necessary, but the overhead of kernel threads is not desired. They
are also useful in systems that lack native multithreading support, allowing
developers to implement threading in a portable way.
Example – User threads library includes POSIX threads, Mach C-Threads
Advantages of User-Level Threads
 Quick and easy to create: User-level threads can be created and
managed more rapidly.
 Highly portable: They can be implemented across various operating
systems.
 No kernel mode privileges required: Context switching can be performed
without transitioning to kernel mode.
Disadvantages of User-Level Threads
 Limited use of multiprocessing: Multithreaded applications may not fully
exploit multiple processors.
 Blocking issues: A blocking operation in one thread can halt the entire
process.
Kernel-Level Thread
Threads are the units of execution within an operating system process. The OS
kernel is responsible for generating, scheduling, and overseeing kernel-level
threads since it controls them directly. The Kernel-level threads are directly
handled by the OS directly whereas the thread’s management is done by the
kernel.
Each kernel-level thread has its own context, including information about the
thread’s status, such as its name, group, and priority.
Example – The example of Kernel-level threads are Java threads, POSIX thread
on Linuxs, etc.
Advantages of Kernel-Level Threads
 True parallelism: Kernel threads allow real parallel execution
in multithreading.
 Execution continuity: Other threads can continue to run even if one is
blocked.
 Access to system resources: Kernel threads have direct access to system-
level features, including I/O operations.
Disadvantages of Kernel-Level Threads
 Management overhead: Kernel threads take more time to create and
manage.
 Kernel mode switching: Requires mode switching to the kernel, adding
overhead.

Parameters User Level Thread Kernel Level Thread

User threads are Kernel threads are

Implemented by implemented by user-level implemented by Operating
libraries. System (OS).

Recognize The operating System Kernel threads are

Parameters User Level Thread Kernel Level Thread

doesn’t recognize user- recognized by Operating

level threads directly. System.

Implementation of Kernel-
Implementation of User
Implementation Level thread is
threads is easy.
complicated.

Context switch Context switch time is Context switch time is

time less. more.

No hardware support is
Hardware Hardware support is
required for context
support needed.
switching.

If one kernel thread

If one user-level thread
performs a blocking
Blocking performs a blocking
operation then another
operation operation then the entire
thread can continue
process will be blocked.
execution.

Multithreaded
applications cannot take Kernels can be
Multithreading
full advantage of multithreaded.
multiprocessing.

User-level threads can be Kernel-level level threads

Creation and
created and managed take more time to create
Management
more quickly. and manage.
Parameters User Level Thread Kernel Level Thread

Any operating system can

Operating Kernel-level threads are
support user-level
System operating system-specific.
threads.

The application code

Thread Managed by a thread doesn’t contain thread
Management library at the user level. management code; it’s
an API to the kernel mode.

POSIX threads, Mach C- Java threads, POSIX

Example
Threads. threads on Linux.

Simple and quick to Allows for true parallelism,

create, more portable, multithreading in kernel
Advantages does not require kernel routines, and can continue
mode privileges for execution if one thread is
context switching. blocked.

Cannot fully utilize Requires more time to

multiprocessing, entire create/manage, involves
Disadvantages
process blocked if one mode switching to kernel
thread blocks. mode.

In kernel-level threads
In user-level threads, each
have their own stacks and
Memory thread has its own stack,
their own separate address
management but they share the same
spaces, so they are better
address space.
isolated from each other.
Parameters User Level Thread Kernel Level Thread

User-level threads are less

Kernel-level threads can be
fault-tolerant than kernel-
managed independently,
level threads. If a user-
Fault tolerance so if one thread crashes, it
level thread crashes, it can
doesn’t necessarily affect
bring down the entire
the others.
process.

Limited access to system It can access to the system-

Resource
resources, cannot directly level features like I/O
utilization
perform I/O operations. operations.

User-level threads are Less portable due to

Portability more portable than dependence on OS-specific
kernel-level threads. kernel implementations.
Single-threaded and Multi-threaded Processes
Single threaded processes contain the execution of instructions in a single
sequence. In other words, one command is processes at a time.
The opposite of single threaded processes are multithreaded processes. These
processes allow the execution of multiple parts of a program at the same time.
These are lightweight processes available within the process.
Difference Between Single-Threaded and Multi-Threaded Processes

Aspect Single-Threaded Process Multi-Threaded Process

Executes multiple tasks

Execution Executes one task at a time. concurrently, either on separate
cores or through time-slicing.

Each process has its own All threads share the same
Memory Usage separate memory space, memory space and resources
making it isolated. within a process.

No sharing of resources with

Threads within the same
other processes unless
Resource process share code, data, and
explicitly communicated
Sharing other resources like file
(e.g., using inter-process
descriptors.
communication).

More responsive because

Less responsive as the entire
threads can perform other tasks
Responsiveness process waits during I/O or
while one thread is waiting,
other blocking operations.
such as during I/O operations.

Performance Limited to the capabilities of Utilizes multi-core processors

a single core. I/O or CPU for parallelism, improving
Aspect Single-Threaded Process Multi-Threaded Process

performance and efficiency,

bottlenecks can slow it down
especially for CPU-intensive or
significantly.
multitasking workloads.

Simpler to design, More complex to design and

implement, and debug since debug due to potential issues
Complexity there's no need to handle like race conditions, deadlocks,
synchronization between and thread management
threads. requirements.

Suitable for linear tasks or Ideal for concurrent or parallel

programs where operations tasks, such as web servers, real-
Use Cases are dependent on the time systems, and applications
previous ones (e.g., text requiring multitasking (e.g.,
editors, calculators). video processing, games).

A crash in one thread can

Failure in a single-threaded potentially impact other
Fault Isolation process typically affects only threads or the entire process
that process. due to shared memory and
resources.

Switching between threads

Switching between processes
within the same process is
incurs higher overhead
Context faster because threads share
because the entire process
Switching resources and memory,
state must be saved and
reducing the need to save and
restored.
restore the entire process.

Detailed Explanation of Each Point

1. Execution:
o Single-Threaded: Executes tasks sequentially, one after another. It
cannot perform multiple operations at the same time. For
 example, if a program is reading a file, it cannot handle user input
simultaneously.
o Multi-Threaded: Can execute multiple tasks simultaneously, either
by leveraging multiple cores or through time-sharing on a single
core. For example, a web browser can load a webpage in one
thread while responding to user input in another.
2. Memory Usage:
o Single-Threaded: Each process has a separate memory area. If two
processes need to share data, explicit mechanisms like pipes or
sockets are needed.
o Multi-Threaded: Threads within a process share the same
memory, allowing faster data sharing but increasing the risk of
overwriting or corrupting data if not synchronized.
3. Resource Sharing:
o Single-Threaded: Resources like files and variables are process-
specific unless explicitly shared.
o Multi-Threaded: Threads share resources, making them more
efficient but requiring careful handling to avoid conflicts.
4. Responsiveness:
o Single-Threaded: If a task is waiting (e.g., for I/O), the whole
process is blocked.
o Multi-Threaded: Other threads can continue executing even if one
thread is blocked, making the system more responsive.
5. Performance:
o Single-Threaded: Limited by the processing power of a single CPU
core. Complex tasks or I/O-bound operations can lead to
underutilized CPU time.
o Multi-Threaded: Can run on multiple cores, performing parallel
tasks and improving throughput for computational or multitasking
workloads.
6. Complexity:
o Single-Threaded: Easier to write and debug because it doesn't
require thread synchronization mechanisms.
o Multi-Threaded: More challenging because developers must
handle synchronization, avoid race conditions, and resolve
potential deadlocks.
7. Use Cases:
o Single-Threaded: Best for tasks requiring sequential processing.
Examples include calculators, basic scripts, or command-line
utilities.
o Multi-Threaded: Used for complex applications requiring
multitasking, such as real-time systems, web servers, or
multimedia applications.
8. Fault Isolation:
o Single-Threaded: If the process crashes, it doesn’t affect other
processes.
o Multi-Threaded: A faulty thread can compromise the whole
process, requiring robust error handling mechanisms.
9. Context Switching:
o Single-Threaded: Switching between processes involves saving and
restoring the full state of the process, which is time-consuming.
o Multi-Threaded: Switching between threads is faster because
threads share the same process resources, reducing the overhead.