Operating Systems MCQ 60 Tests With Answers (2026)

Incorrect·B: A program is a passive entity (a file containing executable code), while a process is an active entity representing that code in execution

A program is simply a static binary file on disk — passive and inert. A process is that program brought to life: it has a Program Counter, an allocated stack, open file descriptors, memory segments, and an entry in the OS process table. One program can spawn many concurrent processes.

Incorrect·A: A data structure maintained by the OS that contains all vital information about a specific process, such as its state, program counter, and CPU registers

The PCB (also called a Task Control Block) is the OS's complete dossier on a process. It stores state (ready/running/blocked), program counter, CPU register values, memory management info, open file list, I/O status, and scheduling priority. It is the data structure that enables context switches.

Incorrect·D: The smallest sequence of programmed instructions that can be managed independently by a scheduler, often referred to as a lightweight process

A thread is the unit of CPU utilization — it has its own program counter, register set, and stack, but shares the code, data, and open files of its parent process. Multiple threads within one process share memory, enabling cheap concurrent execution without the overhead of spawning separate processes.

Incorrect·C: In preemptive scheduling, the OS can forcefully pause a running process to allocate the CPU to another; in non-preemptive, a process yields the CPU voluntarily

In preemptive scheduling, the OS can forcibly evict a running process when a higher-priority one becomes ready or its time quantum expires — enabled by the hardware timer interrupt. Non-preemptive (cooperative) scheduling requires processes to voluntarily release the CPU via system calls or I/O, making it unsuitable for interactive systems.

Incorrect·B: It assigns a fixed time quantum to each process in the ready queue, cycling through them equally to ensure fair CPU allocation

Round Robin assigns each process a fixed time quantum (typically 10–100 ms). After its quantum expires, the process is preempted and placed at the back of the circular ready queue. This ensures fairness and bounded response time, making it the standard algorithm for time-sharing systems.

Incorrect·A: A situation where a low-priority process is perpetually denied CPU time because higher-priority processes continuously arrive and execute

Starvation occurs in priority-based or SJF scheduling when an endless stream of higher-priority/shorter jobs keeps arriving, indefinitely blocking a lower-priority process. The solution is "aging" — gradually increasing the priority of a waiting process over time until it eventually gets scheduled.

Incorrect·D: A memory management technique that creates an illusion of a very large main memory by seamlessly swapping data between RAM and secondary storage

Virtual memory gives each process its own private, large address space (e.g., 4 GB on 32-bit, terabytes on 64-bit) regardless of physical RAM size. Pages not currently needed are stored on disk (swap). The MMU transparently translates virtual to physical addresses, allowing programs larger than RAM to run.

Incorrect·C: A memory management scheme that eliminates the need for contiguous allocation by dividing physical memory into frames and logical memory into blocks of the same size called pages

Paging divides physical RAM into fixed-size frames and a process's logical address space into same-size pages. The page table maps each virtual page to its physical frame. This eliminates external fragmentation — any free frame can hold any page regardless of location, enabling non-contiguous physical allocation.

Incorrect·A: A specialized, high-speed hardware cache within the MMU that stores recent virtual-to-physical address translations to drastically speed up memory access

Without the TLB, every memory access would require at least one additional page-table lookup in RAM — halving performance. The TLB is a small, fully-associative hardware cache (typically 64–1024 entries) inside the MMU that stores recent virtual→physical mappings. A TLB hit requires zero extra RAM accesses; a miss triggers a page table walk.

Incorrect·C: Internal fragmentation is unused memory within an allocated block; external fragmentation is total free memory space that is too scattered (non-contiguous) to satisfy a request

Internal fragmentation: wasted space inside an allocated partition (e.g., a 10 KB block assigned to a 6 KB process wastes 4 KB internally). External fragmentation: enough total free memory exists to satisfy a request, but it is scattered in small non-contiguous chunks. Paging eliminates external fragmentation but retains internal fragmentation.

Incorrect·B: A file system architecture that uses a linked list structure pointing to the physical clusters where a file's data resides on the disk

FAT is a simple table — one entry per disk cluster — where each entry either indicates the cluster is free, holds EOF, or holds the index of the next cluster in the file's chain. FAT12/16/32 differ by the bit-width of cluster indices. Its simplicity made it universal on embedded systems despite lacking permissions and journaling.

Incorrect·D: A phenomenon in page replacement algorithms (like FIFO) where increasing the number of physical page frames actually increases the number of page faults

Discovered by László Bélády in 1969, Bélády's Anomaly shows that FIFO page replacement can produce more page faults with more frames — counterintuitively. The classic example: accessing pages 1,2,3,4,1,2,5 with 3 frames gives 9 faults, but with 4 frames gives 10 faults. LRU and Optimal algorithms do not suffer this anomaly.

Incorrect·A: A state where the system spends significantly more time swapping pages between RAM and disk than executing actual instructions, severely crippling performance

Thrashing occurs when the OS over-commits memory — allowing so many concurrent processes that no process has enough frames for its working set. Every few instructions trigger a page fault, disk I/O dominates, CPU utilization plummets to near zero, and the system appears unresponsive. The Working Set Model prevents thrashing.

Incorrect·B: Mechanisms (like shared memory or message passing) provided by the OS allowing independent processes to exchange data and synchronize their actions

IPC provides mechanisms for cooperating processes (which have separate address spaces) to communicate. Two fundamental models: shared memory (processes map a common region — fast but requires explicit synchronization) and message passing (processes exchange structured messages via OS — cleaner but involves kernel overhead on each call).

Incorrect·D: A hardware feature that allows certain subsystems (like disk controllers) to access main system memory independently of the CPU, freeing the CPU for other tasks

Without DMA, the CPU must supervise every byte of a disk or network transfer — PIO mode wastes enormous CPU cycles. With DMA, the CPU programs the DMA controller (source, destination, count), then continues other work. The DMA controller performs the bulk transfer autonomously and sends a single interrupt when done.

Incorrect·C: It is provably optimal in that it yields the minimum average waiting time for a given set of processes, but predicting the exact length of the next CPU burst is practically difficult

SJF is provably optimal for minimizing average waiting time — by always serving the shortest remaining job first, longer waits are incurred by fewer processes. The critical practical limitation is that the next CPU burst length is unknown; implementations use exponential averaging of past burst lengths to estimate future ones.

Incorrect·D: A process that has completed execution but still has an entry in the process table because its parent process has not yet read its exit status

When a child process exits, it becomes a zombie — the OS releases its resources but retains its PCB entry until the parent calls wait() to collect its exit status. A good parent always reaps its children. If a parent exits without reaping, init (PID 1) adopts and reaps the orphans. Accumulating zombies can exhaust the process table.

Incorrect·A: A virtual memory technique where pages are only loaded into physical memory when they are explicitly referenced or needed during execution, rather than loading the entire program at launch

With demand paging, process startup is nearly instant — no pages are pre-loaded. When the CPU references a page not in RAM, a page fault occurs. The OS locates the page on disk, loads it into a free frame, updates the page table, and resumes the instruction. Only the pages actually needed ever consume physical RAM.

Incorrect·B: A data structure that stores all critical metadata about a file (size, permissions, timestamps, physical block addresses), except for the file's actual name and data

Every file in a Unix file system has exactly one inode. It stores file type, permissions (rwxrwxrwx), UID/GID, size, timestamps (atime/mtime/ctime), link count, and pointers to the actual data blocks (direct, singly indirect, doubly indirect). Directories are simply files that map filenames to inode numbers.

Incorrect·C: A software exception raised by the hardware when a running program attempts to access a memory page that is currently not loaded into physical RAM

When the CPU translates a virtual address and finds the page table entry's "present" bit is 0 (page not in RAM), the MMU raises a page fault interrupt. The OS page fault handler locates the page in swap space, loads it into a free frame (evicting another page if necessary), updates the page table, and restarts the faulting instruction.

Incorrect·D: A timing-dependent flaw where the output or state of a system depends on the unpredictable sequence or timing of uncontrollable events, often leading to data corruption if threads access shared resources simultaneously

A race condition arises when correctness depends on the relative timing of events that the programmer cannot control. Classic example: two threads simultaneously execute counter++ (read, increment, write). If they interleave — both read the same value — one increment is lost. Race conditions are notoriously hard to reproduce and require proper synchronization primitives to prevent.

Incorrect·C: A specific segment of code where a process accesses and modifies shared variables, tables, or files, requiring strict mutual exclusion to prevent data inconsistency

Any code that reads or writes shared mutable state is a critical section. A correct critical section implementation must satisfy three properties: Mutual Exclusion (only one process inside at a time), Progress (a process outside cannot block entry), and Bounded Waiting (a process waiting to enter must eventually succeed).

Incorrect·A: A synchronization primitive used to strictly serialize access to a shared resource, acting as a locking mechanism where only the thread that acquired the lock can release it

A mutex is a binary synchronization primitive with ownership semantics: only the thread that successfully called lock() can later call unlock(). Attempting to lock an already-locked mutex causes the calling thread to block. This ownership model prevents accidental release by the wrong thread, distinguishing mutexes from binary semaphores.

Incorrect·B: A mutex is an ownership-based locking mechanism used for mutual exclusion, whereas a semaphore is a signaling mechanism (often an integer) used to manage access to a finite pool of multiple identical resources

A mutex enforces mutual exclusion with strict ownership — only the locker can unlock. A semaphore is a signaling counter: a counting semaphore initialized to N allows N threads concurrent access (managing N identical resources like database connections). A binary semaphore (0/1) can be used for mutual exclusion, but lacks the ownership constraint of a mutex.

Incorrect·D: A state where a set of processes are permanently blocked because each process is holding a resource and waiting to acquire a resource held by another process in the set

A deadlock is a circular wait among processes: P1 holds R1 and wants R2; P2 holds R2 and wants R1. Neither can proceed without the other releasing first — resulting in permanent blockage. This is not livelock (processes keep changing state but make no progress) nor starvation (indefinitely delayed but still eligible).

Incorrect·C: Mutual Exclusion, Hold and Wait, No Preemption, and Circular Wait

All four Coffman conditions must coexist: (1) Mutual Exclusion — resources are non-shareable; (2) Hold and Wait — processes hold resources while requesting more; (3) No Preemption — resources cannot be forcibly taken; (4) Circular Wait — a cycle exists in the resource-allocation graph. Breaking any one condition prevents deadlock.

Incorrect·B: A deadlock avoidance algorithm that simulates the allocation of predetermined maximum possible resource requests, ensuring the system remains in a "safe state" before formally granting a request

Dijkstra's Banker's Algorithm prevents deadlock by simulating resource allocation before committing. It checks whether granting a request leaves the system in a "safe state" — one from which a sequence exists to run all processes to completion. If unsafe, the request is deferred. The name comes from a bank that only lends if it can still satisfy all potential maximum customer withdrawals.

Incorrect·A: A scenario where a high-priority task is indirectly preempted by a lower-priority task effectively "inverting" the assigned priorities, often because a medium-priority task preempted a low-priority task holding a shared lock

Priority inversion: High-H waits for Low-L to release a mutex. Medium-M (needing no mutex) preempts L, blocking L indefinitely — so H is indirectly blocked by M, inverting their priorities. This famously crashed the Mars Pathfinder rover. The fix is Priority Inheritance: L temporarily inherits H's priority until it releases the lock.

Incorrect·B: A high-level synchronization construct that encapsulates shared data structures, procedures, and synchronization variables within a single abstract data type, inherently enforcing mutual exclusion

A monitor (introduced by Hoare and Hansen) is a programming-language construct that bundles shared data and the procedures that operate on it. The language runtime guarantees that only one thread executes inside the monitor at a time — mutual exclusion is automatic. Condition variables (wait/signal) handle more nuanced synchronization within the monitor.

Incorrect·D: A memory management strategy that tracks the set of pages a process is actively using over a specific time window, helping the OS prevent thrashing by allocating enough frames to cover this set

Denning's Working Set Model defines W(t, Δ) as the set of pages referenced by a process in the past Δ time units. The OS allocates at least |W(t, Δ)| frames to each process. If total demand exceeds physical RAM, some processes are suspended (swapped out) rather than allowing all to thrash. This keeps the system in a productive, non-thrashing state.

Incorrect·C: It replaces the page that has not been accessed for the longest period of time, based on the assumption that pages used heavily in the past will likely be used again soon

LRU exploits temporal locality — pages recently accessed are likely to be needed again soon. It evicts the page with the largest time since last use. LRU is optimal among practical algorithms and does not suffer Bélády's Anomaly. True hardware LRU is expensive; approximations like the Clock Algorithm (second-chance) are used in real systems.

Incorrect·A: A data structure located in lower memory that holds the memory addresses (pointers) of specific Interrupt Service Routines (ISRs), allowing the CPU to quickly context switch and handle specific hardware or software interrupts

The IVT (or IDT on x86-64) is an array indexed by interrupt number. Each entry holds the address of the corresponding ISR. When an interrupt fires, the CPU saves its state, looks up the ISR address in the IVT for that interrupt number, and jumps to it. This enables deterministic, O(1) dispatch to the correct handler for each of up to 256 interrupt types.

Incorrect·B: It utilizes a red-black tree data structure to track the "virtual runtime" of processes, consistently picking the task with the lowest virtual runtime to ensure an equitable distribution of CPU power

Linux CFS (introduced in 2.6.23) tracks "virtual runtime" (vruntime) — effectively the CPU time a process has consumed, weighted by its nice value. All runnable tasks are stored in a red-black tree sorted by vruntime. The scheduler always picks the leftmost node (lowest vruntime). This provides O(log N) scheduling and guarantees mathematically fair CPU distribution.

Incorrect·C: A hardware interrupt generated by electrical noise or a glitching device, where the CPU is signaled but no valid device is actually requesting service when the OS polls the bus

A spurious interrupt is a phantom interrupt caused by hardware noise, bus glitches, or certain 8259 PIC chip behaviors during edge-triggered interrupt handling. When the OS's ISR polls to identify the requesting device, no device acknowledges. The handler must silently acknowledge and discard it to prevent an interrupt storm or system hang.

Incorrect·A: A technique where device registers and I/O buffers are mapped directly into the same physical address space as standard main memory, allowing the CPU to interact with peripherals using standard memory read/write instructions

In memory-mapped I/O (MMIO), device registers occupy ranges in the normal address space. The CPU accesses them with ordinary load/store instructions — no special I/O instructions needed. This simplifies driver code, allows C code to directly manipulate device registers, and is the dominant I/O architecture in modern systems (as opposed to the legacy Port-mapped I/O of x86 IN/OUT instructions).

Incorrect·D: An optimization technique where parent and child processes initially share the exact same memory pages; a separate physical copy of a page is only created when one of the processes attempts to modify it

CoW makes fork() nearly instantaneous: instead of duplicating gigabytes of memory, the kernel marks all parent pages as read-only and shares them. The first write to any shared page triggers a protection fault; the kernel then creates a private copy of just that page for the writing process. Pages never written stay shared forever, saving both time and RAM.

Incorrect·D: A spinlock causes a thread to continuously execute a loop (busy-waiting) to check if the lock is available, whereas a mutex typically puts the waiting thread to sleep, yielding the CPU

A spinlock burns CPU cycles continuously polling the lock bit — wasteful if the critical section is long, but eliminates sleep/wake overhead. A mutex causes a blocked thread to be descheduled (context switch overhead, ~1–2 µs). Spinlocks are preferred in kernel code and SMP scenarios where the critical section is shorter than a context switch and the lock holder is running on another core.

Incorrect·A: A multiprocessor architecture where a specific CPU has faster access to its own local memory node than to memory nodes attached to other CPUs, creating variable memory access times

In a NUMA system (common in multi-socket servers), each CPU socket has local RAM it can access in ~50 ns, while accessing another socket's RAM takes ~100–200 ns. NUMA-aware schedulers (like Linux's) try to keep threads on the NUMA node containing their data. Ignoring NUMA topology can cause severe performance degradation on large servers.

Incorrect·B: It maintains a specialized log (journal) of impending file system changes before they are committed to the main disk structure, allowing for rapid and reliable recovery in the event of a sudden power loss or crash

A journaling file system writes a transaction record (journal entry) to a dedicated circular log before applying changes to the main file system. If power is lost mid-write, the OS replays or rolls back the journal on next mount — recovering in seconds rather than running a full fsck that could take hours on large volumes. ext4, NTFS, HFS+, and XFS all use journaling.

Incorrect·C: A critical layer of software, firmware, or hardware that creates, runs, and manages virtual machines by abstracting and distributing the host's physical hardware resources among them

A Type-1 (bare-metal) hypervisor (VMware ESXi, Microsoft Hyper-V, Xen) runs directly on hardware, hosting guest OSes. A Type-2 (hosted) hypervisor (VirtualBox, VMware Workstation) runs on top of a host OS. Hardware virtualization extensions (Intel VT-x, AMD-V) allow hypervisors to run guest VMs with near-native performance by trapping privileged instructions.