1. What is Process Synchronization?

Explain with an Example

Process Synchronization is a technique to coordinate the execution of processes so that they can

share resources without conflicts. It ensures that multiple processes can run concurrently without

leading to inconsistent results.

Example: Suppose two processes, P1 and P2, are trying to write to the same file. If there is no

synchronization, they may end up corrupting the file content. Process synchronization techniques like

mutex or semaphores can be used to ensure that only one process writes to the file at a time.

2. What is Race Condition? Explain with an Example

A Race Condition occurs when two or more processes access shared data and try to change it

simultaneously, leading to unexpected results.

Example:

int counter = 0;

void increment() {

counter++;

If two threads run the increment() function at the same time, they might both read the value of counter

as 0, increment it, and write back 1 instead of 2. This is due to the lack of synchronization.

3. What is the Critical Section Problem? Explain with an Example

The Critical Section Problem is concerned with ensuring that when one process is executing in its

critical section (a section of code that accesses shared resources), no other process is allowed to

execute in its critical section.

Example: Consider two processes P1 and P2 accessing a shared printer. If both try to print at the

same time, the output will be garbled. We need a mechanism to ensure that only one process can

access the printer at a time.

4. What are the Methods to Stop Race Conditions or Synchronization Mechanisms? Explain

withExamples

To prevent race conditions, we use synchronization mechanisms such as:

Mutex (Mutual Exclusion): Ensures that only one process can access a shared resource.

Example:

pthread_mutex_t lock;

pthread_mutex_lock(&lock); // Lock the critical section

pthread_mutex_unlock(&lock);

An integer variable used to signal between processes.

Example: Binary semaphores (like mutexes) and counting semaphores.

Monitors: High-level synchronization constructs that provide a lock and condition variables.

5. Two-Process Synchronization (Peterson's Algorithm) with Code

Peterson's Algorithm is a classic software-based solution for mutual exclusion between two processes.
Code Example:

bool flag[2] = {false, false};

int turn;

void process0() {

flag[0] = true;

turn = 1;

while (flag[1] && turn == 1);

flag[0] = false;

void process1() {

flag[1] = true;

turn = 0;

while (flag[0] && turn == 0

flag[1] = false;

}
6. Semaphore: Explain Producer-Consumer or Bounded Buffer Problem

The Producer-Consumer Problem involves two types of processes, the producer, and the consumer,

that share a fixed-size buffer. The producer adds items to the buffer, and the consumer removes them.

Solution using Semaphores:

semaphore full = 0;

semaphore empty = N; // Buffer size

semaphore mutex = 1;

void producer() {

while (true) {

produce_item();

wait(empty);

wait(mutex);

add_to_buffer();

signal(mutex);

signal(full);

}
void consumer() {

while (true) {

wait(full);

wait(mutex);

remove_from_buffer();

signal(mutex);

signal(empty);

consume_item();

7. Reader-Writer Problem

The Reader-Writer Problem deals with scenarios where multiple readers can access shared data

simultaneously, but writers need exclusive access.

Readers Priority Solution:

int readcount = 0;

semaphore mutex = 1, wrt = 1;

void reader() {
 wait(mutex);

readcount++;

if (readcount == 1) wait(wrt);

signal(mutex);

// Reading

wait(mutex);

readcount--;

if (readcount == 0) signal(wrt);

signal(mutex);

void writer() {

wait(wrt);

// Writing

signal(wrt);

8. Dining Philosophers Problem

The Dining Philosophers Problem is a classic synchronization problem involving philosophers sitting

at a round table with one fork between each pair. Philosophers must pick up two forks to eat but can

only pick up one fork at a time.

Solution using Semaphores:

semaphore fork[5] = {1, 1, 1, 1, 1}; void

philosopher(int i) {

wait(fork[i]);

wait(fork[(i+1)%5]);

eat();

signal(fork[i]);

signal(fork[(i+1)%5]);

9. What is Deadlock? Necessary Conditions for Deadlock Characterization

A Deadlock is a state where a set of processes are blocked because each process is holding a

resource and waiting for another resource held by another process.

Necessary Conditions:

Mutual Exclusion: At least one resource must be held in a non-shareable mode.

Hold and Wait: Processes holding resources can request new ones.

No Preemption: Resources cannot be forcibly taken from processes.

Circular Wait: A circular chain of processes exists, where each process waits for a resource held by

the next.

10. What is Deadlock Avoidance?

Deadlock avoidance ensures that a system never enters a deadlocked state. It involves analyzing

resource allocation requests to ensure that granting them won't lead to a deadlock.

Banker's Algorithm is a famous deadlock avoidance algorithm.

11. Banker's AlgorithmAlgorithm:

Let Max, Allocation, and Need matrices be defined.

Calculate Need = Max - Allocation.

Check if there exists a safe sequence where all processes can finish.

12. Request Resource Algorithm

To check if a resource request can be safely granted:

Check if the request is within limits.

Temporarily allocate the resources.

Check if the system is in a safe state using Banker's Algorithm.

13. What is Deadlock Detection?

Deadlock detection involves checking the system's state to identify deadlocks, typically using a wait-

for graph.

14. What is Deadlock Recovery? Explain

After detecting a deadlock, recovery can involve:

Process Termination: Kill one or more processes to release resources.

Resource Preemption: Forcefully take resources from some processes.

15. What is Demand Paging? Explain with an Example

Demand Paging is a memory management scheme where pages are loaded into memory only when

required, reducing memory usage.

Example: If a program uses only a portion of its code, only the necessary pages are loaded, saving

space.

16. What is a Page Fault? Steps to Handle Page Faults

A Page Fault occurs when a program tries to access a page not currently in memory.

Steps:

Check if the memory reference is valid.

If invalid, terminate the process.

If valid but not in memory, load the page.

Update the page table and resume execution.

17. What is Page Replacement? Need for Page Replacement?

Page Replacement is needed when a new page needs to be loaded into memory, but there's no free

space. The system must replace an existing page.

Popular Algorithms:

FIFO (First-In-First-Out)

LRU (Least Recently Used)

Optimal Page ReplacemenT