Operating Systems Interview Questions

What should you focus on for an operating systems interview?

Should you start with processes and threads?

Start with processes, threads, and shared data. This topic appeared in 53 of 206 interviews. The most asked question compared processes and threads and asked what problems arise when threads share data.

Check whether you can answer these questions:

• How do processes and threads share data?
• What problems can arise when threads update a shared structure?
• When would you choose multiprocessing over multithreading?

In these interviews, the choice between multiprocessing and multithreading also came up as a follow-up to the process-and-thread comparison.

How much memory knowledge should you cover?

Memory management and data layout appeared in 45 of 206 interviews. Questions covered virtual memory and paging, along with how variables, objects, and collections are stored. Go beyond defining the heap and stack.

• Can you explain what virtual memory is?
• Can you compare the JVM heap, stack, and Metaspace?
• Can you explain value types and reference types, including their storage?
• Can you describe parameter passing and copying?
• Can you explain the memory layout of objects and collections?

What should you know about resource lifetimes?

Garbage collection and resource management appeared in 41 of 206 interviews. Choose the checks that match your language or runtime:

• Can you explain how Java garbage collection works?
• Can you compare unique_ptr, shared_ptr, and weak_ptr and say when you would use each?
• Can you explain how destructors and disposal manage resources?
• Can you describe reference cycles and subscription lifetimes?

These questions cover both memory cleanup and the lifetime of other resources.

Can you explain how you would investigate a memory problem?

The troubleshooting questions covered resource monitoring, profiling tools, heap dumps, retained objects, and allocation overhead.

Can you describe how you would investigate a memory leak? Say which profiling tools you would use and what you would examine in a heap dump. Can you explain how you would look for retained objects? Also check whether you can discuss caching and allocation overhead, rather than only define a memory leak.

Should you prepare for large files and coding tasks?

For large data and out-of-memory questions, check whether you can explain streaming, batching, backpressure, and container memory limits.

Coding tasks appeared in 3 of 206 interviews. Use these tasks to test yourself:

• Write a script that checks a process’s status and logs the result.
• Write a loop that reads from a file and writes its contents to another.
• Write code that sends standard output to a file.
• Process a file of URLs that cannot fit in memory. Produce a file containing each unique URL and its count.

Who gets asked Operating Systems

The 20 most asked Operating Systems questions

Counted by interview, not by mention: a question asked twice in one conversation counts once.

1. How do processes and threads differ, and what problems arise when threads share data?

   Asked in 34 of 206 interviews · last asked Oct 23 · Concept · Junior

   Show answer

   A process is a running program with its own address space; a thread is an execution path within a process. Threads share process memory but have separate stacks and CPU registers. Shared data can cause race conditions, lost updates, or inconsistent results. Synchronization protects shared data, but incorrect locking can cause deadlocks.

   • Processes normally isolate memory; sharing data requires communication or explicitly shared memory.
   • Threads share code, heap memory, and resources such as open files.
   • Creating threads and switching between them is usually cheaper than doing so with processes.
   • Use locks or suitable atomic operations for shared updates; keep lock ordering consistent to avoid deadlocks.

   What the interviewer checks: The interviewer checks whether you understand memory isolation, shared resources, and safe access to shared data.

   Other ways it was asked

   • “What is the difference between a process and a thread?”
   • “What is the difference between a thread and a process?”
   • “In your own words, what is the difference between a process and a thread in an operating system?”

2. When would you choose multiprocessing over multithreading?

   Asked in 21 of 206 interviews · last asked Oct 23 · Scenario · Mid-level

   Show answer

   I would choose multiprocessing for CPU-heavy work when the language runtime limits threads from running it in parallel, or when tasks need stronger isolation. Processes can use separate CPU cores, but they cost more memory and make data sharing harder. Threads often suit I/O-heavy work or tasks that share data.

   • Processes have separate address spaces, giving stronger memory and fault isolation.
   • Threads can also run in parallel across cores if the runtime allows it.
   • Process creation and communication usually cost more than creating threads and sharing memory.
   • Multiprocessing works best when tasks are independent enough to outweigh communication costs.

   What the interviewer checks: The interviewer is checking whether you can weigh parallelism, isolation, and communication costs for the workload.

   Other ways it was asked

   • “When would you choose multiple processes instead of multiple threads?”
   • “When would you choose to use multiple processes?”
   • “When would you choose multiprocessing over threading for a specific task?”

3. How does Java garbage collection work, and how do you investigate garbage collection and memory problems?

   Asked in 7 of 206 interviews · last asked Oct 16 · Concept · Junior

   Show answer

   Java garbage collection reclaims heap memory from objects no longer reachable from GC roots, such as live threads and static fields. It can cause pauses and use CPU; behavior depends on the JVM and collector. I examine GC logs, allocation rates, and heap usage, then use heap dumps and profiling to find the cause.

   • Frequent collections can indicate heavy allocation; growing heap usage after collection can suggest retained objects.
   • Use heap dumps to inspect retained sizes and paths to GC roots.
   • Java 9 and later support GC logging with -Xlog:gc*; older versions use different flags.
   • Check native memory too: an OutOfMemoryError does not always mean the Java heap is full.

   What the interviewer checks: The interviewer checks whether you understand object reachability, GC performance costs, and how to diagnose memory problems using evidence.

   Other ways it was asked

   • “What is garbage collection, and how can it affect the performance of a Java application?”
   • “What is garbage collection in .NET?”
   • “Can you explain garbage collection?”

4. What are the JVM memory areas, and how do the heap, stack, and Metaspace differ?

   Asked in 6 of 206 interviews · last asked Oct 22 · Concept · Senior

   Show answer

   The JVM has a shared heap and method area, plus per-thread stacks, program counters, and native method stacks. The heap holds objects and arrays; stacks hold method calls, local variables, and temporary results. In HotSpot Java 8 and later, Metaspace stores class metadata in native memory as part of the method area.

   • The heap is shared across threads; garbage collection reclaims unreachable objects.
   • Each thread has its own Java stack; method calls create frames containing values and object references.
   • Metaspace is outside the heap; class unloading can release its metadata.
   • Deep calls can cause StackOverflowError; exhausted heap or Metaspace can cause OutOfMemoryError.

   What the interviewer checks: The interviewer checks whether you understand what each area stores, which areas threads share, and how memory is released.

   Other ways it was asked

   • “How is memory structured inside the Java JVM?”
   • “How does the JVM memory model work?”
   • “What are the heap, stack, and Metaspace in the JVM, and how do they differ?”

5. How do value types and reference types differ, including how they are stored in memory?

   Asked in 4 of 206 interviews · last asked Sep 10 · Concept · Junior

   Show answer

   In C#, value-type variables hold values; reference-type variables hold references to objects. Assignment copies the value or reference, so copied references share an object. Value types can live on the stack or inside heap objects. Reference-type objects live on the managed heap; their references can be stored on the stack or heap.

   • Structs and enums are value types; classes, arrays, and strings are reference types.
   • Value type does not mean stack storage. Storage depends on where the value is used.
   • Boxing copies a value into an object on the managed heap.
   • Copying a struct copies its fields; reference fields still point to the same objects.

   What the interviewer checks: The interviewer checks whether you understand copying, shared objects, and why type alone does not determine storage.

   Other ways it was asked

   • “Do you know the difference between reference types and value types?”
   • “Tell me a bit about the differences between value types and reference types.”
   • “What is the difference between reference types and value types?”

6. How do processes and threads share data, and what does that mean for safely updating shared structures?

   Asked in 3 of 206 interviews · last asked Apr 4 · Concept · Senior

   Show answer

   Processes normally have separate memory and share data through messages or explicitly shared memory. Threads share a process's address space, though language runtimes may isolate their variables. Updates to shared structures need synchronization, such as locks, to prevent races; a read followed by a write is not automatically one safe operation.

   • Changing a normal variable in one process does not change it in another.
   • Protect the whole shared update, not just individual reads or writes.
   • Node.js workers isolate JavaScript objects; messages usually copy data, while SharedArrayBuffer allows shared memory.
   • Python offers multiprocessing.Queue and manager-backed dictionaries; the GIL does not make compound dictionary updates safe.

   What the interviewer checks: The interviewer checks whether you understand memory isolation, data-sharing methods, and how to prevent race conditions.

   Other ways it was asked

   • “How do you share data between processes compared to sharing data between threads?”
   • “In Python, what are the key differences between a process and a thread in terms of memory isolation and sharing data structures such as a queue or dictionary?”
   • “How is memory shared or not shared between threads and processes, and what does that imply for safely updating a shared dictionary?”

7. What is virtual memory?

   Asked in 3 of 206 interviews · last asked Oct 12 · Concept · Junior

   Show answer

   Virtual memory gives each process its own address space, separate from physical RAM. The operating system and hardware map virtual addresses to physical memory. This helps isolate processes and manage memory. It can also let programs use more memory than available RAM by moving less-used pages to disk.

   • Virtual addresses are translated to physical addresses, usually through page tables.
   • Memory protection helps prevent one process from accessing another process’s memory.
   • A page fault may occur when a needed page is not in RAM.
   • Frequent swapping between RAM and disk can slow programs down.

   What the interviewer checks: The interviewer is checking whether you understand address translation, process isolation, and the role of disk-backed memory.

   Other ways it was asked

   • “What is virtual memory and why do we use it?”

8. How do unique_ptr, shared_ptr, and weak_ptr differ, and when would you use each?

   Asked in 3 of 206 interviews · last asked Oct 4 · Concept · Mid-level

   Show answer

   std::unique_ptr owns an object alone; use it by default when ownership is not shared. std::shared_ptr shares ownership and deletes the object when the last shared owner releases it. std::weak_ptr observes a shared_ptr-managed object without keeping it alive; use it to break ownership cycles or access an object that may be gone.

   • unique_ptr cannot be copied, but moving it transfers ownership.
   • shared_ptr can be copied; reference counting adds memory and runtime costs.
   • weak_ptr::lock() returns a shared_ptr, or an empty one if the object has expired.
   • shared_ptr manages lifetime; it does not make access to the object thread-safe.

   What the interviewer checks: The interviewer checks whether you can choose clear ownership rules and avoid leaks or access to destroyed objects.

   Other ways it was asked

   • “What are the key differences between std::unique_ptr and std::shared_ptr in C++?”
   • “What is the difference between std::unique_ptr and std::shared_ptr, and when would you choose one over the other?”
   • “Could you expand on how you decide between using unique_ptr, shared_ptr, and weak_ptr in a real system?”

9. What is the difference between an HDD and an SSD?

   Asked in 3 of 206 interviews · last asked Sep 3 · Concept · Junior

   Show answer

   An HDD stores data on spinning magnetic disks and uses a moving head to read and write. An SSD stores data in flash memory and has no moving parts. SSDs are usually faster, quieter, and more resistant to physical shocks. HDDs usually cost less per unit of storage.

   • Both keep data when power is off.
   • SSDs have lower access delays, especially for small reads and writes at different locations.
   • HDDs are often cheaper for storing large amounts of data.
   • SSD flash cells have limited write cycles; both types can fail.

   What the interviewer checks: The interviewer is checking whether you understand how the storage technology affects speed, cost, and durability.

   Other ways it was asked

   • “What is the difference between SSD and HDD?”

10. What is an operating system?

    Asked in 2 of 206 interviews · last asked Aug 6 · Concept · Junior

    Show answer

    An operating system is system software that manages a computer’s hardware and provides services for applications. It manages the CPU, memory, files, and input and output devices. It also controls access to resources so programs can run safely and share the computer.

    • Manages hardware resources such as CPU time, memory, and devices.
    • Provides services that applications use through system calls.
    • Manages files and controls access to protect data and programs.

    What the interviewer checks: The interviewer checks whether you understand the operating system’s role between applications and hardware.

11. What is a kernel?

    Asked in 2 of 206 interviews · last asked Oct 12 · Concept · Junior

    Show answer

    The kernel is the core part of an operating system. It manages CPU time, memory, and devices. Programs use system calls to request its services, and it helps keep programs from interfering with each other.

    • Schedules processes and threads to share CPU time.
    • Manages memory and controls access to hardware.
    • Provides system calls for programs to request operating system services.
    • Runs with privileges that ordinary programs do not have.

    What the interviewer checks: The interviewer is checking whether you understand the kernel’s role in managing resources and connecting programs to hardware.

    Other ways it was asked

    • “What is a kernel in an operating system?”

12. What is the difference between CPU-bound and I/O-bound tasks?

    Asked in 2 of 206 interviews · last asked Sep 29 · Concept · Mid-level

    Show answer

    CPU-bound tasks spend most of their time doing calculations. I/O-bound tasks spend most of their time waiting for data, such as disk reads or network responses. CPU-bound tasks benefit mainly from faster processing, while I/O-bound tasks benefit mainly from faster I/O or overlapping work with waiting.

    • The difference is which resource limits the task's speed.
    • Image processing is often CPU-bound; downloading files is often I/O-bound.
    • Concurrency can overlap I/O waits; CPU-heavy work needs available CPU cores to run in parallel.
    • A task can switch between CPU-bound and I/O-bound phases.

    What the interviewer checks: The interviewer checks whether you can identify the main bottleneck and choose a suitable way to improve performance.

    Other ways it was asked

    • “Can you please explain the difference between IO-bound and CPU-bound tasks?”

13. What is the difference between a process and a service in Linux?

    Asked in 2 of 206 interviews · last asked Oct 7 · Concept · Junior

    Show answer

    A process is a running instance of a program, with its own process ID (PID). A service is a managed task that provides a function, such as a web server, usually in the background. A service can use one or more processes and is often managed by systemd.

    • Processes can run in the foreground or background; not every background process is a service.
    • Service managers can start, stop, and restart services, and start them at boot.
    • Some services run continuously; others finish after completing a task.

    What the interviewer checks: The interviewer checks whether you distinguish a running program from a managed system function.

    Other ways it was asked

    • “What are Linux processes and services, and how do they differ?”

14. What is the difference between shallow and deep copying, and when does it matter for nested objects?

    Asked in 2 of 206 interviews · last asked Aug 14 · Concept · Junior

    Show answer

    A shallow copy creates a new outer object but keeps references to the same nested objects. A deep copy recursively copies nested objects, so changes to copied mutable data do not affect the original. This matters when editing nested lists or objects, such as during ML preprocessing.

    • Changing a shared nested object affects both shallow copies.
    • Replacing an item in the copied outer container does not change the original container.
    • Deep copying usually takes more time and memory.
    • In Python, use copy.copy() for shallow copying and copy.deepcopy() for deep copying.

    PythonCopy

    import copy
    
    original = [[1, 2], [3, 4]]
    shallow = copy.copy(original)
    deep = copy.deepcopy(original)
    shallow[0][0] = 99
    print(original)  # [[99, 2], [3, 4]]
    print(deep)      # [[1, 2], [3, 4]]

    What the interviewer checks: The interviewer checks whether you understand shared references and can avoid unintended changes to nested data.

    Other ways it was asked

    • “What's the difference between a shallow copy and a deep copy, and why does it matter when copying arrays or objects?”
    • “In Python, what's the practical difference between a shallow copy and a deep copy of a nested list, and when would it matter in an ML preprocessing pipeline?”

15. How do NumPy views and copies differ, and how can you check whether a slice shares memory?

    Asked in 2 of 206 interviews · last asked Jun 3 · Concept · Mid-level

    Show answer

    A NumPy view shares its data with the original array, while a copy has separate data. Changing shared elements through a view also changes the original. Use np.shares_memory(original, sliced) to check for shared memory, and sliced.copy() when you need independent data.

    • Basic slicing returns a view; integer-array and Boolean indexing return copies.
    • np.shares_memory checks whether two arrays actually share memory.
    • np.may_share_memory is conservative: True means sharing is possible, not certain.
    • The .base attribute alone does not prove that two arrays share memory.

    PythonCopy

    import numpy as np
    
    original = np.arange(6)
    view = original[1:4]
    copy = view.copy()
    print(np.shares_memory(original, view))  # True
    print(np.shares_memory(original, copy))  # False
    view[0] = 99
    print(original[1], copy[0])  # 99 1

    What the interviewer checks: The interviewer is checking whether you understand shared array data and can prevent accidental changes.

    Other ways it was asked

    • “In NumPy, how does a view differ from a copy, and how can you tell which one you got after slicing?”
    • “In NumPy, what's the difference between a view and a copy, and how do you prevent accidental data mutation when slicing?”
    • “How would you check in code whether a sliced NumPy array shares memory with the original array?”

16. What happens during boxing in C#, where is the object allocated, and how does it affect performance?

    Asked in 2 of 206 interviews · last asked Aug 6 · Concept · Mid-level

    Show answer

    Boxing converts a value type, such as int, into an object containing a copy of its value. The boxed object is normally allocated on the managed heap. Frequent boxing adds allocation and copying costs and creates more work for the garbage collector.

    • Passing an int to a method parameter of type object causes boxing.
    • Changing the original value does not change the boxed copy.
    • Generic collections, such as List<int>, avoid boxing when storing integers.

    CodeCopy

    int value = 42;
    object boxed = value; // Boxing: copies 42 into an object.
    value = 99;
    System.Console.WriteLine(boxed); // Prints 42.

    What the interviewer checks: The interviewer is checking whether you understand value copying, heap allocation, and the performance cost of boxing.

    Other ways it was asked

    • “What happens when an integer value is passed to a C# method that accepts an object?”
    • “Where is the object allocated when a C# value type is passed as an object?”
    • “What is boxing in C#, and how can frequent boxing affect application performance? Give a concrete example.”

17. How do std::vector reserve and resize differ in allocation, capacity, size, and element values?

    Asked in 2 of 206 interviews · last asked Oct 4 · Concept · Junior

    Show answer

    reserve(n) can increase capacity, but leaves size and element values unchanged. It reallocates only when n exceeds capacity. resize(n) changes size, constructing added elements or destroying removed elements; it reallocates only if the new size exceeds capacity. Added elements are default-inserted, or copied from the value supplied to resize(n, value).

    • Capacity counts available element slots; size counts live elements. Reserved slots are not valid elements to access.
    • Reallocation moves or copies existing elements into new storage, invalidating all existing pointers, references, and iterators.
    • Neither call reduces capacity. After growth, capacity may be greater than n.
    • With the standard allocator, resize(n) adds zero-valued integers; class elements use their default constructors.

    What the interviewer checks: The interviewer checks whether you distinguish allocated storage from live elements and understand construction, destruction, and reallocation.

    Other ways it was asked

    • “In C++, when you call reserve(n) on a vector, what exactly happens in memory if n is greater than the current capacity?”
    • “In a vector, what's the difference between reserve(n) and resize(n) in terms of element construction, destruction, and observable size?”
    • “What is the difference between reserve and resize on a std::vector, and what happens to size and element values in each case?”

18. How is a doubly linked list node structured, and what memory overhead does it have versus an array?

    Asked in 2 of 206 interviews · last asked Oct 17 · Concept · Senior

    Show answer

    A doubly linked list node stores a value and links to the previous and next nodes. Each node needs extra memory for these two links, plus possible allocation overhead and padding. In Java, LinkedList nodes hold three references: item, previous, and next. Compared with ArrayList, each element adds two link references and a separate node object's overhead.

    • ArrayList stores element references in one backing array, with no separate node objects.
    • A dynamic array may reserve unused capacity, which also costs memory.
    • Exact overhead depends on reference size, object headers, alignment, and the runtime.

    What the interviewer checks: The interviewer checks whether you can describe node fields and compare their memory cost with array storage.

    Other ways it was asked

    • “How is a doubly linked list node laid out in memory, what references or fields does it store, and what extra overhead does it have compared with a dynamic array?”
    • “In Java, how is a LinkedList node structured, what references does it hold, and what extra memory cost does that imply per element versus an ArrayList?”

19. Can you explain what pointers point to and how they are used in C and C++?

    Asked in 2 of 206 interviews · last asked Oct 9 · Concept · Junior

    Show answer

    In C and C++, a pointer stores the address of an object or function, or a null value that points to nothing. Pointers let code access objects indirectly, modify a caller’s data, and work with arrays and dynamic memory. They are also used to build structures such as linked lists and trees.

    • Use & to get an object’s address and * to access the object through a pointer.
    • Only dereference pointers to live, valid objects; never dereference null, uninitialized, or dangling pointers.
    • Pointer arithmetic stays within one array or one position past it; never dereference that past-the-end position.
    • C commonly uses malloc and free; C++ usually prefers containers and smart pointers for dynamic memory.

    CodeCopy

    int value = 10;
    int *ptr = &value;  // ptr points to value
    *ptr = 20;          // value is now 20

    What the interviewer checks: The interviewer checks whether you understand addresses, indirect access, and safe use of memory.

    Other ways it was asked

    • “Can you explain pointers in C++, how they are used, and why they are useful?”
    • “What are pointers in C++?”

20. What are static variables?

    Asked in 2 of 206 interviews · last asked Dec 4 · Concept · Junior

    Show answer

    In Java, static variables belong to a class, not to each object. All objects of that class share the same variable. You can access it through the class name without creating an object.

    • Declared with the static keyword.
    • Useful for shared state, such as a count of objects created.
    • Static does not mean constant; the variable can change unless it is also final.
    • Static variables are not automatically thread-safe; shared updates may need synchronization.

    What the interviewer checks: The interviewer checks whether you understand class-level state versus separate state for each object.

    Other ways it was asked

    • “What are static variables in Java?”

Related interview questions

• Software Engineer interview questions
• System Administrator interview questions
• DevOps Engineer interview questions
• AI Engineer interview questions
• Data Engineer interview questions
• Data Structures and Algorithms interview questions
• OOP and Design Patterns interview questions
• System Design interview questions
• Microservices interview questions
• REST API interview questions
• Kafka and Message Queues interview questions
• Caching and Redis interview questions
• Computer Networks interview questions
• Git interview questions

How this list is made

Every question here was asked by a real interviewer in a real job interview that a candidate ran MeetAssist in. After the call, the interviewer's questions are pulled from the transcript. Practice sessions, tests, exams and anything that was not a job interview are dropped.

Questions are rewritten so they make sense on their own: names of people, employers and clients are removed, and speech-to-text mistakes are fixed. Small talk, logistics and questions about one candidate's own résumé are left out. Rephrasings of the same question are merged, and the count is the number of different interviews it came up in.

The interviews come from candidates who use MeetAssist, so they lean towards software, data and AI roles: the shares describe these interviews, not every Operating Systems interview. Answers to the most asked questions are written and checked by an editor; a "common mistake" is shown only when reviews of real answers in these interviews show it, with the count.

206 interviews, 166 candidates, Dec 2025 to Oct 2026. Updated every month with new interviews.