Concurrency & Parallel Processing (Senior) sample questions with answers

H effectively runs at L's priority because it is waiting on L, and Med preempts L, so a medium-priority task delays the highest-priority one for an unbounded time. With priority inheritance, L temporarily inherits H's priority while H waits on M, so Med can no longer preempt it. The priority ceiling protocol is the other common remedy.

gather wraps each coroutine in a task and they start in argument order. tick 1 runs until sleep(0) yields. hog then runs its whole loop without any await, so "hog end" follows "hog start" directly, and every other task waits. Then tick 2 starts, and the resumed ticks finish. Cooperative scheduling only switches at awaits.

Condition.wait_for(predicate, timeout) loops on wait() until the predicate is true or the timeout passes, then returns the predicate's last value. Here nothing sets ready, so it prints False (verified on Python 3.13). Checking the return value is how you distinguish "condition met" from "gave up".

Each worker_threads worker runs in its own OS thread with its own V8 isolate and event loop, so CPU-bound work in different workers runs in parallel. Workers don't share ordinary JS objects; they communicate with postMessage (structured clone or transfer) or share raw memory through SharedArrayBuffer.

The slot holds 9 and the expected value is 5, so the compare fails and 7 is not written. compareExchange returns the value it found (9), so the caller detects failure by seeing that the return value differs from the expected 5. Verified in Node 24.

CPU-bound work must leave the event-loop thread. A bounded pool of worker threads or processes (sized to the cores, and processes where a GIL prevents parallel threads) lets the loop await results while still handling I/O. The bound on the pool and its queue keeps overload from exhausting memory and turns it into backpressure or explicit rejection.

Under Hoare semantics the signalled thread takes over the monitor at once and the condition is guaranteed to hold. Java, Python, pthreads and Go use Mesa semantics: notify() only moves a waiter to the "ready" state; the notifier keeps running and other threads may enter first. The woken thread must re-check its predicate in a loop.

An unbounded queue hides a rate mismatch until memory or latency explodes. Backpressure needs a signal back to the producer: a bounded queue whose put blocks or fails, credit-based flow control, or a reactive request(n) protocol. Buffers smooth bursts; they cannot fix a sustained mismatch.

UPDATE acquires row-level locks regardless of isolation level. If transaction 1 locks row 1 and transaction 2 locks row 2, each then waits for the other's row. After deadlock_timeout PostgreSQL detects the cycle and aborts one transaction with SQLSTATE 40P01. The documented prevention is to lock rows in a consistent order in every transaction.

io_uring uses two ring buffers shared between user space and the kernel: the program places operations (read, write, accept, and more) in the submission queue, and the kernel posts results to the completion queue. Because it is completion-based, it can batch many operations per system call and also handle regular-file I/O asynchronously, which epoll cannot.