How do I approach System Design interview questions?

System Design questions require understanding of core concepts and practice. PracHub provides solutions with explanations to help you master system design interviews.

What difficulty level is this interview question?

This is a hard difficulty System Design question, commonly asked during Take-home Project rounds at Akuna Capital.

What role is this question designed for?

This question is commonly asked for Software Engineer candidates at Akuna Capital during technical interviews.

Fix and harden an object pool | Akuna Capital Interview Question

Quick Overview

This question evaluates concurrent programming and systems-level C++ skills, including thread-safe generic template design, synchronization with mutexes/condition_variables and atomics, ABA mitigation, RAII-based resource management, fairness in wait queues, and safe shutdown semantics.

Refactor a Buggy C++ Object Pool Into a Correct, Thread-Safe Template

Context

You are given a buggy C++ object pool that suffers from races, double-free risks, ABA problems, and resource leaks during concurrent borrow/return operations. Refactor it into a robust template that is correct under concurrency and safe to shut down.

Assume C++17 or later.

Requirements

Implement a generic, thread-safe object pool template for objects of type T.
Provide borrow() that blocks when the pool is empty and creates up to a maximum capacity.
- Also provide an overload with a timeout (e.g., borrow_for(duration)).
- Ensure fairness among waiters (FIFO) and avoid spurious wakeups.
Provide returnObject(obj) to safely return an object:
- Reject invalid returns (wrong pool) and duplicate returns.
- Optionally reset objects before reuse (configurable functor).
Enforce RAII via a scoped handle that returns the object automatically when destroyed.
- Handle must be movable but not copyable.
Ensure safe shutdown:
- Destructor stops producers/consumers, wakes waiters, and releases resources without deadlocks.
Avoid busy-waiting; use std::mutex, std::condition_variable, and std::atomic correctly.
Prevent ABA issues (e.g., generation counters per item).
Include minimal unit tests demonstrating correctness under multiple threads.
Document the time complexity of core operations.

Deliverables: A single self-contained C++17 implementation plus minimal unit tests and brief complexity notes.

Quick Overview

Requirements

Implement a generic, thread-safe object pool template for objects of type T.

Provide borrow() that blocks when the pool is empty and creates up to a maximum capacity.

Also provide an overload with a timeout (e.g., borrow_for(duration)).
Ensure fairness among waiters (FIFO) and avoid spurious wakeups.

Provide returnObject(obj) to safely return an object:

Reject invalid returns (wrong pool) and duplicate returns.
Optionally reset objects before reuse (configurable functor).

Enforce RAII via a scoped handle that returns the object automatically when destroyed.

Handle must be movable but not copyable.

Ensure safe shutdown:

Destructor stops producers/consumers, wakes waiters, and releases resources without deadlocks.

Avoid busy-waiting; use std::mutex, std::condition_variable, and std::atomic correctly.

Prevent ABA issues (e.g., generation counters per item).

Include minimal unit tests demonstrating correctness under multiple threads.

Document the time complexity of core operations.

Deliverables: A single self-contained C++17 implementation plus minimal unit tests and brief complexity notes.

Fix and harden an object pool

Quick Overview

Refactor a Buggy C++ Object Pool Into a Correct, Thread-Safe Template

Context

Requirements

Solution

Comments (0)

Fix and harden an object pool

Quick Overview

Refactor a Buggy C++ Object Pool Into a Correct, Thread-Safe Template

Context

Requirements

Solution

Comments (0)