RepostedConfluent logo

Confluent · Phone screen → Onsite

In process

Confluent Older Concurrency Rounds: 12 Experiences (Part 2 of 2)

Software engineer · UnknownReported Dec 10, 2021
Shared byjanebeingjane

Confluent concurrency interviews, 2018–2021: twelve earlier reports dominated by a thread-safe delayed task scheduler and LRU caches with locking.

At a glance

Coverage: 12 software engineering reports from 2018 to 2021 (one new graduate, one full-stack track), entries 17–28 of the 28-report Confluent concurrency collection. All are more than three years old, so they sit in History below.

In this Confluent collection

What came up

The delayed task scheduler dominated these years, and interviewers cared about the threading: when to notify a waiting consumer, what a synchronized method locks, and why not to poll. Because every report here is older than three years, this part has no current tables; each question stays in its entry.

History (before 2023)

H17: adding shutdown after the scheduler

Report date: December 10, 2021 · Result: Not stated

  1. A DelayedScheduler; the interviewer found bugs quickly, then asked for a shutdown function (graceful or immediate not stated).

H18: a producer/consumer scheduler with Java follow-ups

Interview date: Q2 2021 · Result: Not stated

  1. About 20 minutes on approaches and threading basics, then a delayed-task scheduler with producer and consumer: a priority queue with synchronized push and pop, run on a thread pool.
  2. Follow-ups: when to notify the consumer so it neither misses the next job nor wakes too often (timed wait); what a synchronized method locks; what happens when it calls wait; alternatives to synchronized; why use a thread pool.

H19: a delayed queue built leader/follower style

Interview date: Q2 2021 · Result: Not stated

  1. DelaySchedule modeled on Java's delayed queue, with a min-heap, synchronized wait/notify and a thread-pool executor; leader/follower was the candidate's own choice.

H20: the library shortcut was refused

Report date: June 7, 2021 · Result: Not stated

  1. A job scheduler with delay; using ScheduledExecutorService was refused. The talk focused on optimizing wait/notify and avoiding needless checks, plus broader multithreading and JVM memory questions.

H21: expiry cleanup before the threading talk

Interview date: Q2 2021 · Role: Full-stack track · Result: Not stated

  1. A windowed key-value map with 30-minute expiry and an average of unexpired values; cleanup during get made it linear. Near the end: handling reads and writes from many threads.

H22: a scheduler that only ordered tasks

Interview date: Q2 2021 · Result: Not stated

  1. schedule(Runnable task, long delayMs), explicitly without execution or multithreading. The candidate stored tasks by delay and discussed a heap versus binary-search insertion; there was disagreement over the available C# tools.

H23: the missing blocking priority queue mattered

Interview date: Q1 2021 · Result: Feedback that the threading was not strong enough

  1. A task scheduler with schedule(long delay) and required multithreading. The candidate assumed a blocking priority queue existed and wrote wait/notify around it; the interviewer noted the queue itself was never built.

H24: a single-threaded version, then two threads

Interview date: Q1 2021 · Result: Not stated

  1. A first coding round that began single-threaded, then moved to a producer and consumer with a priority queue and a lock; the task was not named.

H25: runnables, delays and a producer/consumer queue

Report date: September 16, 2020 · Result: Pending

  1. Store and schedule runnable tasks with millisecond delays: a delayed-task runner where a producer adds jobs to a priority queue and a consumer runs them; the queue's own design was not the point.

H26: locking both LRU structures, then scheduling runnables

Interview date: Q1 2019 · Result: Not stated

  1. Phone screen: an LRU cache, then concurrency; the candidate locked both the list and the map, and proposed hashing keys into separate lists.
  2. Onsite: a TaskScheduler with a schedule(task, delay) API, implemented without ScheduledExecutorService.

H27: LRU follow-ups on lock-free approaches

Interview date: December 13, 2018 · Role: New graduate · Result: Not stated

  1. An LRU cache with a doubly linked list and hash map, then multithreading, locks and lock-free approaches (discussed, not coded).

H28: thread safety after an LRU implementation

Interview date: Q2 2018 · Result: Not stated

  1. An LRU cache, then how to make it thread-safe while keeping it efficient.

Common questions

What was the Confluent delayed scheduler question?

Schedule runnable tasks with a delay and run them on time from multiple threads, usually a priority queue with a producer and consumer and careful wait/notify (H18, H19, H23, H25).

Can you use ScheduledExecutorService in the Confluent interview?

Not in these reports: two candidates were told to build it themselves (H20, H26).

Keep practicing

In this Confluent collection

Sources: Anywhere useful interview info can be found.

0 total reactions. Your reactions: none.
0 comments

Comments

0

No comments yet — be the first to share what you know.