Error Handling and Defensive Programming Questions

// update only if both reference and stamp match
AtomicStampedReference<Node> head = new AtomicStampedReference<>(null, 0);
int[] stampHolder = new int[1];
Node cur = head.get(stampHolder);
int stamp = stampHolder[0];
Node newHead = ...;
head.compareAndSet(cur, newHead, stamp, stamp+1);

public class CircuitBreaker {
  enum State { CLOSED, OPEN, HALF_OPEN }
  private State state = State.CLOSED;
  private final int failureThreshold;
  private final Duration window;
  private final Duration cooldown;
  private final Deque<Long> failureTimestamps = new ArrayDeque<>();
  private long openUntil = 0;
  private final AtomicBoolean probeInFlight = new AtomicBoolean(false);

  public CircuitBreaker(int failureThreshold, Duration window, Duration cooldown) {
    this.failureThreshold = failureThreshold;
    this.window = window;
    this.cooldown = cooldown;
  }

  public <T> T call(Supplier<T> remoteCall, Supplier<T> fallback) {
    long now = System.currentTimeMillis();
    pruneOldFailures(now);
    if (state == State.OPEN) {
      if (now >= openUntil) {
        state = State.HALF_OPEN;
      } else {
        emit("rejected");
        return fallback.get();
      }
    }

    if (state == State.HALF_OPEN) {
      if (!probeInFlight.compareAndSet(false, true)) {
        emit("rejected");
        return fallback.get();
      }
    }

    try {
      T result = remoteCall.get();
      onSuccess();
      return result;
    } catch (Exception e) {
      onFailure(now);
      return fallback.get();
    } finally {
      probeInFlight.set(false);
    }
  }

  private void onSuccess() {
    failureTimestamps.clear();
    state = State.CLOSED;
    emit("success");
  }

  private void onFailure(long now) {
    failureTimestamps.addLast(now);
    pruneOldFailures(now);
    emit("failure");
    if (failureTimestamps.size() >= failureThreshold) {
      state = State.OPEN;
      openUntil = now + cooldown.toMillis();
      emit("opened");
    } else if (state == State.HALF_OPEN) {
      state = State.OPEN;
      openUntil = now + cooldown.toMillis();
      emit("opened");
    }
  }

  private void pruneOldFailures(long now) {
    long cutoff = now - window.toMillis();
    while (!failureTimestamps.isEmpty() && failureTimestamps.peekFirst() < cutoff) {
      failureTimestamps.removeFirst();
    }
  }

  private void emit(String metric) { /* hook to metrics system */ }
}

// POST /orders with Idempotency-Key
app.post('/orders', async (req, res) => {
  const key = req.get('Idempotency-Key');
  if (!key) return res.status(400).send('Missing Idempotency-Key');
  const existing = await db.findIdempotency(key);
  if (existing) return res.status(existing.status).json(existing.body);
  const tx = await db.transaction();
  try {
    const order = await createOrder(tx, req.body);
    await db.saveIdempotency(key, 201, order);
    await tx.commit();
    res.status(201).json(order);
  } catch (e) { await tx.rollback(); throw e; }
});