Types of Operating Systems MCQ 60 Tests With Answers (2026)

Incorrect·C: A Network OS makes users explicitly aware of multiple separate machines, whereas a Distributed OS completely hides the hardware locations, making the network appear as one single computer.

NOS = user sees \\server\share (explicit). Distributed OS = user sees /home/file (transparent location hiding). True distributed OSes aim for location independence.

Incorrect·D: In AMP, a specific "master" processor controls the system and assigns tasks to "slave" processors, whereas in SMP, all processors are treated as equal peers.

AMP = one master CPU runs the kernel, slave CPUs handle specific workloads (e.g., GPU compute). SMP = all CPUs run the kernel, any can schedule any task.

Incorrect·C: Rapid context switching triggered by a hardware timer interrupt, allowing the OS to preempt running processes and assign the CPU to the next process in the ready queue.

Concurrency on a single CPU is achieved via rapid context switching enabled by hardware timer interrupts. The actual parallelism is illusory but timescale fast enough for the user to perceive it.

Incorrect·B: Memory protection mechanisms (like base and limit registers or pagination) to ensure that one process cannot accidentally or maliciously overwrite the memory space of another process.

Without memory protection, multiprogramming is unsafe — a bug in one process can crash others. Memory protection (MMU with paging/segmentation) is foundational.

Incorrect·B: It is a software layer that sits above the base OS to provide common services, protocols, and APIs, enabling disparate, heterogeneous nodes to communicate seamlessly.

Middleware (like CORBA, RPC, gRPC, message brokers) abstracts heterogeneous hardware/OS differences, providing unified communication and resource access APIs across distributed nodes.

Incorrect·C: Jobs are submitted alongside all their required data and commands upfront; once execution begins, the user cannot provide dynamic input until the entire batch finishes or fails.

In batch systems, users submit jobs (punch cards) without interaction. If a running job hangs or requests user input, it blocks until manual intervention. This is the trade-off for high CPU utilization.

Incorrect·D: The system behaves almost exactly like a First-Come-First-Served (FCFS) batch system, causing poor response times for interactive users.

If quantum is too large (e.g., 10 seconds), then by the time a process yields, other waiting users have experienced unacceptable lag. Time-sharing requires small quanta (10–100 ms).

Incorrect·A: Guaranteeing strict determinism and predictability so that the worst-case execution time (WCET) of critical tasks never exceeds the mandated deadline.

RTOS schedulers (e.g., EDF, Rate Monotonic) use priority-based preemption with strict WCET bounds to guarantee deadline compliance. Fairness is secondary.

Incorrect·B: High availability and fault tolerance; if one entire physical machine (node) within the cluster fails, the others can take over its workload, whereas an SMP system shares a single motherboard/memory that represents a single point of failure.

Clustered OSes provide fault tolerance — a node failure doesn't take the system down. SMP systems fail if the shared motherboard/memory fails (single point of failure).

Incorrect·D: It allowed the system to read jobs from slow card readers onto a fast magnetic disk in the background, decoupling the CPU's execution speed from the extremely slow mechanical I/O devices.

Spooling (Simultaneous Peripheral Operations On-Line) buffers slow I/O to fast disk. A card reader could write spooled jobs overnight while the CPU processed yesterday's spool in parallel.

Incorrect·B: An active process or file can be moved from one physical node to another without the user or application knowing, and without disrupting ongoing operations.

Migration Transparency means processes/services can move between nodes for load balancing or maintenance without the client noticing. The OS abstracts node boundaries.

Incorrect·C: To provide the OS with precise, automated instructions on how to execute a specific job, including compiler choices, memory requirements, and file locations, since no human operator could intervene.

JCL (IBM System/360) was a control language specifying job parameters: compiler, input/output handling, memory allocation, tape mounting — all defined upfront since user interaction was impossible.

Incorrect·B: The shared system bus and main memory; as more CPUs are added, contention for shared memory bandwidth increases, potentially causing starvation.

SMP scalability is limited by memory bus bandwidth. All CPUs contend for a single shared bus/memory — as you add CPUs, memory contention increases (cache coherence overhead, bandwidth saturation).

Incorrect·C: It runs directly on the bare-metal hardware, bypassing a traditional host OS, to specifically allocate CPU, memory, and I/O resources to multiple distinct guest virtual machines.

Type 1 (bare-metal) hypervisors (VMware ESXi, Xen, Hyper-V) run directly on hardware like an OS. Type 2 hypervisors run as applications within a host OS.

Incorrect·D: Priority-based preemptive scheduling, ensuring that higher-priority multimedia or critical tasks always preempt lower-priority background tasks.

Soft RTOS uses priority-based preemption to minimize latency for important tasks (media playback, input handling) while tolerating occasional misses of non-critical deadlines.

Incorrect·D: A stringent security architecture where each application runs in an isolated environment with restricted access to system resources and other applications' data, requiring explicit user permissions to bridge boundaries.

Mobile app sandboxing (iOS's XPC, Android's SELinux/domain) restricts each app to its own file namespace, preventing one app from accessing another's data or the system kernel without permission prompts.

Incorrect·B: A Directory Service, such as Active Directory or LDAP, providing a centralized, hierarchical database of network resources and identities.

Directory Services (Active Directory, LDAP, FreeIPA) are the backbone of NOS — they centralize user/group/computer/permission management, enabling single sign-on and unified access control.

Incorrect·A: It allows a high-priority hardware interrupt or system call to immediately interrupt and replace a currently executing lower-priority kernel process, minimizing latency.

RTOS kernels must be preemptive — a high-priority task must be able to instantly interrupt lower-priority work (even kernel code) to meet tight deadlines. Non-preemptive kernels introduce unpredictable latency.

Incorrect·C: Because there is no global shared memory, independent nodes experience "clock drift," making it inherently difficult to establish a definitive, global chronological order of events without specialized logical algorithms (like Lamport timestamps).

Distributed systems cannot rely on synchronized clocks (network latency limits sync accuracy). Logical clocks (Lamport, vector clocks, HLC) establish causal ordering of events instead.

Incorrect·B: In Client-Server, a dedicated centralized machine manages resources and security; in Peer-to-Peer, all computers act as equals, sharing resources directly with one another without centralized control.

Client-Server NOS = centralized services/control (AD, file shares via server). P2P = no central authority (BitTorrent, blockchain nodes) — each peer is both client and server.

Incorrect·C: It states that a distributed data store can simultaneously provide at most two out of three guarantees: Consistency, Availability, and Partition Tolerance, heavily influencing distributed file system design.

CAP Theorem (Brewer's Theorem) limits distributed systems: strong Consistency + Availability = no network partition handling. Systems must choose: CA (fail on partition), CP (eventual consistency), or AP (eventual consistency).

Incorrect·C: By utilizing protocols (like MESI) where the hardware/OS snoops the system bus to ensure that if one CPU modifies a shared memory block in its local L1 cache, all other CPUs invalidate or update their local copies of that block.

Cache coherence protocols (MESI, MOESI, MESIF) maintain consistency: when CPU1 writes a line, bus snooping invalidates/updates CPU2's copy. This prevents stale cache reads.

Incorrect·B: A scheduling technique where the OS avoids migrating a process to a different CPU core to ensure the process continues to benefit from data already loaded in the original core's L1/L2 cache, maximizing cache hit rates.

CPU affinity pins a process to a core, avoiding cache thrashing from migrations. If process moves to a new core with cold caches, TLB/L1/L2 misses spike, hurting performance.

Incorrect·D: A scenario where a high-priority task is forced to wait for a lower-priority task to release a shared resource (like a Mutex), effectively "inverting" their priorities and potentially causing the high-priority task to miss a critical deadline.

Priority inversion: High-priority task waits for low-priority task holding a mutex. If a medium-priority task preempts the low-priority one, the high-priority task is starved. Mars Pathfinder suffered this bug.

Incorrect·C: By temporarily elevating the priority of the lower-priority task holding the lock to match the priority of the waiting high-priority task, ensuring the lock is released as quickly as possible.

Priority Inheritance: When high-priority task blocks on low-priority task's mutex, temporarily boost the mutex holder's priority to high. It executes, releases the lock, priority drops back. Prevents starvation.

Incorrect·B: A Microkernel strips out nearly all services (file systems, drivers, networking) into isolated user-space processes, meaning a crash in a device driver will not panic or crash the core kernel.

Microkernel: minimal kernel (IPC, scheduling, memory) + drivers/FS in user space. A driver crash doesn't panic the kernel. Monolithic: all services in kernel, one crash = kernel panic.

Incorrect·A: A situation where a network partition causes independent nodes in the cluster to lose communication and independently assume they are the master, leading to simultaneous, conflicting writes to the shared storage and massive data corruption.

Split-brain: cluster partitions, both sides think they're the primary. Both write to shared storage, data corruption ensues. Quorum/STONITH prevents this.

Incorrect·B: By utilizing STONITH (Shoot The Other Node In The Head) fencing mechanisms or establishing a strict quorum (majority vote) rule to ensure only the dominant partition can access the shared storage.

Quorum: in a 3-node cluster, if partition is 2 vs 1, the 2-node side has quorum and becomes primary. STONITH: if a node vanishes, stonith it (power off) so it can't corrupt shared storage.

Incorrect·D: It provides a software abstraction that allows independent, physically separated nodes on a network to share a logical virtual address space, catching page faults over the network to fetch missing data blocks from remote nodes.

DSM (e.g., IVY, MUNIN): shared virtual memory abstraction across network. Page fault triggers RPC to fetch page from the node holding it. Transparent to application code.

Incorrect·B: To provide an interface where a program can execute a subroutine or procedure in another address space (commonly on a remote server) just as if it were a local function call, utilizing client and server stubs for data marshaling.

RPC (ONC RPC, gRPC, XML-RPC) abstracts remote calls: client stub marshals args, sends request, server stub unmarshals, invokes function, returns result. Transparent to caller.

Incorrect·B: The degree of multiprogramming becomes so high that active working sets exceed physical memory; the OS spends vastly more time swapping pages to and from the disk than executing actual CPU instructions, dropping CPU utilization near zero.

Thrashing: too many processes with total working sets > RAM. Every instruction triggers a page fault. Disk I/O dominates, CPU idle. The Working Set Model prevents this.

Incorrect·B: It allows a distributed system to reach consensus and continue operating correctly even if some of the nodes fail arbitrarily or act maliciously (e.g., sending conflicting information to different peers).

BFT (PBFT, Raft with byzantine extensions): even if f nodes lie/crash, remaining nodes reach agreement if n > 3f. Requires message authentication, voting.

Incorrect·C: To aggressively pause CPU execution of apps not currently on-screen, conserving severe amounts of battery life and preserving constrained RAM for the active foreground application.

Mobile OSes suspend background apps to save battery and constrain RAM. iOS/Android only resume on user interaction or scheduled tasks, minimizing power drain.

Incorrect·A: It assigns a dynamic, mathematically calculated priority to processes based entirely on how close their absolute completion deadline is, proving theoretically optimal for preemptive uniprocessors.

EDF: always run the task with the earliest absolute deadline. Provably optimal (100% utilization for feasible schedules) on uniprocessors. Dynamic priority.

Incorrect·C: A specific background task continuously monitors the load across all CPUs and actively moves (pushes) processes from an overloaded CPU's ready queue to an idle or less-busy CPU's ready queue.

Push migration: load balancer detects imbalance, moves tasks from busy to idle cores. Reduces contention, improves utilization (opposite: pull migration where idle CPUs request work).

Incorrect·B: It abstracts the complex, block-erasure nature of flash memory, presenting a standard logical sector interface to the OS while managing critical background tasks like wear leveling and garbage collection.

FTL: makes flash (erase-block-oriented, limited write cycles) appear like a disk (sector-addressable). Manages wear leveling, bad-block mapping, garbage collection transparently.

Incorrect·B: It assigns fixed, static priorities to tasks based on their period; tasks with shorter periods (higher frequency) are assigned higher preemptive priorities.

RMS: shorter-period tasks get higher priority. For independent periodic tasks, RMS achieves 100% CPU utilization (processor utilization bound ≈ 0.693 for general case).

Incorrect·C: By separating processes into different queues based on their behavior; CPU-bound processes that consume full time-slices are demoted to lower-priority queues, while interactive, I/O-bound processes are promoted to higher-priority queues to ensure rapid response times.

MLFQ: moves interactive processes (yield early) to high-priority queues, CPU-bound tasks (use full quantum) to low-priority. Balances responsiveness vs. throughput.

Incorrect·C: A mechanism to assign a strict, consistent partial ordering of events across a distributed network without requiring physically synchronized hardware clocks.

Lamport Clocks: logical counter (not wall-clock time) that establishes causal ordering. If A→B in causality, then A.clock < B.clock. Solves distributed ordering without synchronized clocks.

Incorrect·D: To flawlessly execute massive, highly structured, data-intensive tasks (like payroll processing for millions of accounts or nightly banking reconciliations) with maximum CPU throughput and zero interactive delays.

Mainframe batch processing (z/OS, IBM i) remains the gold standard for high-volume, non-interactive workloads: bank reconciliation, payroll, insurance claims processing — prioritizing throughput over latency.