BOWEN UNIVERSITY, IWO

COLLEGE OF COMPUTING AND COMMUNICATION STUDIES

DEPARTMENT OF COMPUTER SCIENCE
CSC 322- OPERATING SYSTEM II
LECTURE NOTE 1

Introduction

Concurrency in operating systems refers to the ability of an operating system to

handle multiple tasks or processes at the same time. With the increasing demand
for high performance computing, concurrency has become a critical aspect of
modern computing systems. Operating systems that support concurrency can
execute multiple tasks simultaneously, leading to better resource utilization,
improved responsiveness, and enhanced user experience. Concurrency is essential
in modern operating systems due to the increasing demand for multitasking, real-
time processing, and parallel computing. It is used in a wide range of applications,
including web servers, databases, scientific simulations, and multimedia
processing. However, concurrency also introduces new challenges such as race
conditions, deadlocks, and priority inversion, which need to be managed
effectively to ensure the stability and reliability of the system.
Principles of Concurrency

The principles of concurrency in operating systems are designed to ensure that

multiple processes or threads can execute efficiently and effectively, without
interfering with each other or causing deadlock.

 Interleaving − Interleaving refers to the interleaved execution of multiple

processes or threads. The operating system uses a scheduler to determine
which process or thread to execute at any given time. Interleaving allows for
efficient use of CPU resources and ensures that all processes or threads get a
fair share of CPU time.
 Synchronization − Synchronization refers to the coordination of multiple
processes or threads to ensure that they do not interfere with each other. This
is done through the use of synchronization primitives such as locks,
semaphores, and monitors. These primitives allow processes or threads to
coordinate access to shared resources such as memory and I/O devices.
 Mutual exclusion − Mutual exclusion refers to the principle of ensuring that
only one process or thread can access a shared resource at a time. This is
typically implemented using locks or semaphores to ensure that multiple
processes or threads do not access a shared resource simultaneously.
 Deadlock avoidance − Deadlock is a situation in which two or more
processes or threads are waiting for each other to release a resource,
resulting in a deadlock. Operating systems use various techniques such as
resource allocation graphs and deadlock prevention algorithms to avoid
deadlock.
 Process or thread coordination − Processes or threads may need to
coordinate their activities to achieve a common goal. This is typically
 achieved using synchronization primitives such as semaphores or message
passing mechanisms such as pipes or sockets.
 Resource allocation − Operating systems must allocate resources such as
memory, CPU time, and I/O devices to multiple processes or threads in a fair
and efficient manner. This is typically achieved using scheduling algorithms
such as round-robin, priority-based, or real-time scheduling.

Concurrency Mechanisms

These concurrency mechanisms are essential for managing concurrency in

operating systems and are used to ensure safe and efficient access to system
resources.

 Processes vs. Threads − An operating system can support concurrency

using processes or threads. A process is an instance of a program that can
execute independently, while a thread is a lightweight process that shares the
same memory space as its parent process.
 Synchronization primitives − Operating systems provide synchronization
primitives to coordinate access to shared resources between multiple
processes or threads. Common synchronization primitives include
semaphores, mutexes, and condition variables.
 Scheduling algorithms − Operating systems use scheduling algorithms to
determine which process or thread should execute next. Common scheduling
algorithms include round-robin, priority-based, and real-time scheduling.
 Message passing − Message passing is a mechanism used to communicate
between processes or threads. Messages can be sent synchronously or
asynchronously and can include data, signals, or notifications.
  Memory management − Operating systems provide memory management
mechanisms to allocate and manage memory resources. These mechanisms
ensure that each process or thread has its own memory space and can access
memory safely without interfering with other processes or threads.
 Interrupt handling − Interrupts are signals sent by hardware devices to the
operating system, indicating that they require attention. The operating
system uses interrupt handling mechanisms to stop the current process or
thread, save its state, and execute a specific interrupt handler to handle the
device's request.

Advantages of concurrency in Operating System

Concurrency provides several advantages in operating systems, including −

 Improved performance − Concurrency allows multiple tasks to be

executed simultaneously, improving the overall performance of the system.
By using multiple processors or threads, tasks can be executed in parallel,
reducing the overall processing time.
 Resource utilization − Concurrency allows better utilization of system
resources, such as CPU, memory, and I/O devices. By allowing multiple
tasks to run simultaneously, the system can make better use of its available
resources.
 Responsiveness − Concurrency can improve system responsiveness by
allowing multiple tasks to be executed concurrently. This is particularly
important in real-time systems and interactive applications, such as gaming
and multimedia.
  Scalability − Concurrency can improve the scalability of the system by
allowing it to handle an increasing number of tasks and users without
degrading performance.
 Fault tolerance − Concurrency can improve the fault tolerance of the
system by allowing tasks to be executed independently. If one task fails, it
does not affect the execution of other tasks.

Problems in Concurrency

These problems can be difficult to debug and diagnose and often require careful
design and implementation of concurrency mechanisms to avoid.

 Race conditions occur when the output of a system depends on the order and
timing of the events, which leads to unpredictable behavior. Multiple
processes or threads accessing shared resources simultaneously can cause
race conditions.
 Deadlocks occur when two or more processes or threads are waiting for each
other to release resources, resulting in a circular wait. Deadlocks can occur
when multiple processes or threads compete for exclusive access to shared
resources.
 Starvation occurs when a process or thread cannot access the resource it
needs to complete its task because other processes or threads are hogging the
resource. This results in the process or thread being stuck in a loop, unable
to make progress.
  Priority inversion occurs when a low-priority process or thread holds a
resource that a high-priority process or thread needs, resulting in the high-
priority process or thread being blocked.
 Memory consistency refers to the order in which memory operations are
performed by different processes or threads. In a concurrent system, memory
consistency can be challenging to ensure, leading to incorrect behavior.
 Deadlock avoidance techniques can prevent deadlocks from occurring, but
they can lead to inefficient use of resources or even starvation of certain
processes or threads.

Real-World Applications of Concurrency

Multithreaded web servers

Web servers need to handle multiple requests simultaneously from multiple clients.
A multithreaded web server uses threads to handle multiple requests concurrently,
improving its performance and responsiveness.

Concurrent databases

Databases are critical for many applications, and concurrency is essential to

support multiple users accessing the same data simultaneously. Concurrent
databases use locking mechanisms and transaction isolation levels to ensure that
multiple users can access the database safely and efficiently.

Parallel computing

Parallel computing involves breaking down large problems into smaller tasks that
can be executed simultaneously on multiple processors or computers. This
approach is used in scientific computing, data analysis, and machine learning,
where parallel processing can significantly improve the performance of complex
algorithms

Future Directions for Concurrency in Operating Systems

Future directions for concurrency in operating systems are focused on developing

new programming models and languages, hardware support, and algorithms to
address the challenges of concurrency.

New programming models and languages

New programming models and languages are emerging to simplify the

development of concurrent software and reduce the likelihood of concurrency
bugs. For example, Rust is a programming language that uses a unique ownership
model to enforce memory safety and avoid data races. Other programming
languages like Go and Swift also provide built-in support for concurrency.

Hardware support for concurrency

Hardware support for concurrency is also advancing rapidly, with multi-core

processors, GPUs, and specialized accelerators becoming more prevalent. Future
directions for hardware support include better integration between hardware and
software to minimize overhead and improve performance. Additionally, new
hardware architectures are being developed, such as transactional memory and
hardware enforced synchronization mechanisms, to reduce the likelihood of
concurrency bugs.

New algorithms and data structures

Finally, new algorithms and data structures are being developed to support
efficient and scalable concurrency. For example, lock-free data structures and
algorithms use synchronization primitives that do not block, allowing multiple
tasks to access shared data simultaneously. Additionally, new algorithms and data
structures are being developed to support distributed computing and parallel
processing, allowing tasks to be executed across multiple machines or processors.

Conclusion

Concurrency is a critical aspect of modern operating systems and plays a

significant role in supporting the performance, scalability, and fault tolerance of
modern applications and systems. While concurrency provides several advantages,
it also poses several challenges, such as race conditions, deadlocks, and memory
consistency issues. Operating systems provide various mechanisms to manage
concurrency, including processes, threads, synchronization primitives, scheduling
algorithms, message passing, memory management, and interrupt handling. The
development of new technologies and applications is driving the need for more
efficient and scalable concurrency mechanisms.