Balking — Find the Bug¶

private boolean started = false;
public boolean start() {          // NOT synchronized
    if (started) return false;
    started = true;
    init();
    return true;
}

private volatile boolean closed = false;
public void close() {
    if (closed) return;
    closed = true;     // still two separate operations
    cleanup();
}

public synchronized void save() {
    if (!changed) return;
    changed = false;          // reset FIRST
    writeToDisk(content);     // throws IOException sometimes
}

writeToDisk(content);
changed = false;             // only on success

private boolean ready = false;            // plain field
public void markReady() { ready = true; } // writer thread
public boolean tryUse() {                 // reader thread
    if (!ready) return false;             // may NEVER see the write
    use(); return true;
}

public void close() {
    if (closed.compareAndSet(false, true)) {
        // winner does nothing here?!
    } else {
        releaseResources();   // WRONG: loser runs cleanup
    }
}

public Item take() {
    if (queue.isEmpty()) return null;   // balk
    return queue.poll();
}
// consumer:
Item i = take();
process(i);                              // NPE when it balked

public void capturePayment(String key) {
    if (captured.contains(key)) return;  // silent balk
    captured.add(key);
    gateway.charge(key);
}

if (!captured.add(key)) {          // atomic on a concurrent set
    metrics.counter("capture.double_submit").increment();
    log.warn("capture balked: {} already processed", key);
    return;
}

private Object lock = new Object();
public void start() {
    synchronized (lock) {
        if (started) return;
        lock = new Object();   // reassigning the lock mid-method
        started = true; init();
    }
}

private boolean done = false;          // not volatile
public void runOnce(Runnable r) {
    if (done) return;                  // fast path
    synchronized (this) {
        if (done) return;
        r.run();
        done = true;
    }
}

public void close() {
    while (!closed.compareAndSet(false, true)) {
        // spin
    }
    cleanup();   // EVERY caller eventually runs this
}

if (!engine.start()) {
    throw new IllegalStateException("could not start engine");
}