Monitor Object — Practice Tasks¶

Ten graded, build-it-yourself tasks for the Monitor Object pattern. Each gives a goal, requirements, hints, and a solution sketch. Work in Java (intrinsic lock or ReentrantLock + Condition); add C++ where noted. See junior · middle.

Table of Contents¶

1. Task 1 — Thread-Safe Counter
2. Task 2 — Bounded Buffer (intrinsic lock)
3. Task 3 — Bounded Buffer (two conditions)
4. Task 4 — Timed poll / offer
5. Task 5 — CountDownLatch from scratch
6. Task 6 — Bounded Semaphore
7. Task 7 — Connection Pool
8. Task 8 — Read/Write Gate (single writer)
9. Task 9 — One-Shot Future / Promise
10. Task 10 — Reproduce and Fix Nested Monitor Lockout
11. How to Practice

Task 1 — Thread-Safe Counter¶

Goal: Build a counter safe for concurrent increment/get and prove visibility.

Requirements: increment(), decrement(), get(), all correct under N threads doing M increments each so the final value equals N×M.

Hints: Synchronize the reader too — not just the writer. Why? Visibility under the JMM.

public final class Counter {
    private long value;
    public synchronized void increment() { value++; }
    public synchronized void decrement() { value--; }
    public synchronized long get()       { return value; }
}

Task 2 — Bounded Buffer (intrinsic lock)¶

Goal: Implement the canonical Monitor example with synchronized + wait/notifyAll.

Requirements: put(x) blocks when full, take() blocks when empty; FIFO order; no busy-waiting.

Hints: while (full) wait(); and while (empty) wait();. Use notifyAll() (single condition, mixed waiters). Null out slots on removal to avoid leaks.

public synchronized void put(T x) throws InterruptedException {
    while (count == items.length) wait();
    items[tail] = x; tail = (tail + 1) % items.length; count++;
    notifyAll();
}
public synchronized T take() throws InterruptedException {
    while (count == 0) wait();
    T x = (T) items[head]; items[head] = null;
    head = (head + 1) % items.length; count--;
    notifyAll();
    return x;
}

Task 3 — Bounded Buffer (two conditions)¶

Goal: Refactor Task 2 to ReentrantLock + notFull/notEmpty and replace notifyAll with signal.

Requirements: signal() (not signalAll()); lock() outside try, unlock() in finally.

Hints: Producers await on notFull and signal notEmpty; consumers the mirror. Argue why signal is now safe (homogeneous waiters per condition).

public void put(T x) throws InterruptedException {
    lock.lock();
    try {
        while (count == items.length) notFull.await();
        // enqueue...
        notEmpty.signal();
    } finally { lock.unlock(); }
}

Task 4 — Timed poll / offer¶

Goal: Add deadline-aware variants that give up after a timeout.

Requirements: poll(timeout, unit) returns null on timeout; offer(x, timeout, unit) returns false. Deadline must survive spurious wakeups.

Hints: Use awaitNanos, which returns the remaining nanos; subtract across loop iterations.

public T poll(long timeout, TimeUnit unit) throws InterruptedException {
    long nanos = unit.toNanos(timeout);
    lock.lock();
    try {
        while (count == 0) {
            if (nanos <= 0L) return null;
            nanos = notEmpty.awaitNanos(nanos);   // remaining time
        }
        // dequeue...
        notFull.signal();
        return x;
    } finally { lock.unlock(); }
}

Task 5 — CountDownLatch from scratch¶

Goal: Implement a one-shot latch: workers await() until count reaches zero.

Requirements: await() blocks until count == 0; countDown() decrements; once open, stays open (all future await() return immediately).

Hints: Single condition "count == 0". countDown() signals only when it hits zero. await() uses while (count > 0) wait();.

public final class Latch {
    private int count;
    public Latch(int n) { count = n; }
    public synchronized void await() throws InterruptedException {
        while (count > 0) wait();
    }
    public synchronized void countDown() {
        if (count > 0 && --count == 0) notifyAll();   // wake all waiters
    }
}

Task 6 — Bounded Semaphore¶

Goal: Implement a counting semaphore with N permits.

Requirements: acquire() blocks when no permits; release() returns one; never exceed max permits.

Hints: Condition "permits > 0". release signals one waiter. Make acquire interruptible.

public final class Sem {
    private final Lock lock = new ReentrantLock();
    private final Condition avail = lock.newCondition();
    private int permits;
    public Sem(int p) { permits = p; }
    public void acquire() throws InterruptedException {
        lock.lock();
        try { while (permits == 0) avail.await(); permits--; }
        finally { lock.unlock(); }
    }
    public void release() {
        lock.lock();
        try { permits++; avail.signal(); }
        finally { lock.unlock(); }
    }
}

Task 7 — Connection Pool¶

Goal: A fixed-size pool that blocks borrowers when exhausted.

Requirements: borrow(timeout) returns a connection or times out; release(conn) returns it; never hand out the same connection twice.

Hints: Hold idle connections in a deque; condition "pool not empty". Combine with Task 4's timed wait. Always release in a finally at the call site.

Task 8 — Read/Write Gate (single writer)¶

Goal: Allow many readers OR one writer, never both — a hand-rolled read/write lock as a Monitor.

Requirements: readLock/readUnlock, writeLock/writeUnlock. Writers wait for active readers to drain; readers wait while a writer holds or is queued (writer preference to avoid starvation).

Hints: Track activeReaders, writerActive, waitingWriters. Conditions: "can read", "can write". This is genuinely tricky — get starvation policy explicit.

Task 9 — One-Shot Future / Promise¶

Goal: A set(value) once, get() blocks until set.

Requirements: get() blocks until a value (or exception) is available; multiple getters all unblock; set is idempotent-or-throws.

Hints: Condition "isDone". Store either a value or a throwable. notifyAll on completion.

public synchronized V get() throws InterruptedException {
    while (!done) wait();
    if (error != null) throw new ExecutionException(error);
    return value;
}
public synchronized void complete(V v) {
    if (done) throw new IllegalStateException("already completed");
    value = v; done = true; notifyAll();
}

Task 10 — Reproduce and Fix Nested Monitor Lockout¶

Goal: Deliberately create a nested-monitor deadlock, observe it, then fix it.

Requirements: Two objects A and B; a thread holds A, enters B, and wait()s on B while still holding A; a second thread needs A to change B's condition. Show the hang (timeout test), then fix.

Hints: The fix is to not wait while holding the outer lock — restructure so the wait happens with only one lock held, or pass the needed data without nesting.

How to Practice¶

1. Write the stress test first. For every task, a multi-threaded harness asserting the invariant (count bounds, conservation of items, no double-issue) is worth more than the implementation. Run it for millions of ops.
2. Deliberately break it. Change while to if, swap signal for the wrong condition, drop reader synchronization — watch the stress test catch it. Bugs you've seen fail you'll recognize in code review.
3. Pin interleavings with latches. Use CountDownLatch/CyclicBarrier to force the exact two-thread order that triggers lost-wakeup or nested-lockout, turning flaky bugs into deterministic tests.
4. Build both versions. Do each task once with synchronized+wait/notifyAll and once with ReentrantLock+Condition; feel where the explicit version's targeted signal wins.
5. Then read the JDK. After building Task 3, read ArrayBlockingQueue; after Task 5, read CountDownLatch (AQS). Your hand-rolled version makes the source legible.
6. Add a timeout to every blocking test — a hang is the failure signal for deadlock and lost-wakeup bugs.