Java Scenario-Based Interview Questions

// THE PROBLEM: Lock ordering violation
public void transfer(Account from, Account to, BigDecimal amount) {
    synchronized (from) {         // Thread A locks Account-1
        synchronized (to) {       // Thread A waits for Account-2 (held by B)
            from.debit(amount);
            to.credit(amount);
        }
    }
}

public void transfer(Account from, Account to, BigDecimal amount) {
    // Always acquire locks in consistent order (by ID)
    Account first = from.getId() < to.getId() ? from : to;
    Account second = from.getId() < to.getId() ? to : from;

    synchronized (first) {
        synchronized (second) {
            from.debit(amount);
            to.credit(amount);
        }
    }
}

public void transfer(Account from, Account to, BigDecimal amount) {
    boolean gotBoth = false;
    while (!gotBoth) {
        if (from.getLock().tryLock(100, TimeUnit.MILLISECONDS)) {
            try {
                if (to.getLock().tryLock(100, TimeUnit.MILLISECONDS)) {
                    try {
                        from.debit(amount);
                        to.credit(amount);
                        gotBoth = true;
                    } finally {
                        to.getLock().unlock();
                    }
                }
            } finally {
                from.getLock().unlock();
            }
        }
        if (!gotBoth) Thread.sleep(randomBackoff());
    }
}

// Bounded queue with backpressure
BlockingQueue<Event> queue = new ArrayBlockingQueue<>(10_000);

// Producer: blocks when queue is full (natural backpressure)
public void produce(Event event) throws InterruptedException {
    if (!queue.offer(event, 5, TimeUnit.SECONDS)) {
        // Queue full for 5 seconds — send to dead letter queue
        deadLetterQueue.send(event);
        metrics.increment("events.dropped");
    }
}

// Consumer: batch processing for throughput
public void consumeLoop() {
    List<Event> batch = new ArrayList<>(100);
    while (running) {
        queue.drainTo(batch, 100); // grab up to 100 at once
        if (!batch.isEmpty()) {
            processBatch(batch);
            batch.clear();
        } else {
            Thread.sleep(10); // avoid busy spin
        }
    }
}

// Approach 1: synchronized method (simple but blocks all threads)
public class ServiceRegistry {
    private static ServiceRegistry instance;

    public static synchronized ServiceRegistry getInstance() {
        if (instance == null) {
            instance = new ServiceRegistry(); // expensive
        }
        return instance;
    }
    // Downside: every get() call pays synchronization cost
}

// Approach 2: Holder pattern (lazy, lock-free, recommended)
public class ServiceRegistry {
    private static class Holder {
        static final ServiceRegistry INSTANCE = new ServiceRegistry();
    }

    public static ServiceRegistry getInstance() {
        return Holder.INSTANCE; // class loaded only on first access
    }
    // Best: no synchronization, guaranteed by JVM classloading
}

// Approach 3: Enum (simplest, serialization-safe)
public enum ServiceRegistry {
    INSTANCE;

    // constructor runs once, thread-safe by JVM guarantee
    ServiceRegistry() { /* expensive init */ }
}

// BUG: Thread B may never see the update
class Worker implements Runnable {
    private boolean running = true; // NOT volatile

    public void run() {
        while (running) { // JIT may hoist this read out of loop
            doWork();
        }
    }

    public void stop() {
        running = false; // Thread A writes, but B never sees it
    }
}

// FIX: volatile ensures visibility across threads
private volatile boolean running = true;

// volatile doesn't help here — compound operation (read-modify-write)
private volatile int counter = 0;

public void increment() {
    counter++; // NOT atomic! (read → add → write)
}

// Fix: use AtomicInteger
private final AtomicInteger counter = new AtomicInteger(0);

public OrderSummary getOrderSummary(String orderId) {
    CompletableFuture<Order> orderFuture = CompletableFuture
        .supplyAsync(() -> orderService.getOrder(orderId));

    CompletableFuture<Payment> paymentFuture = CompletableFuture
        .supplyAsync(() -> paymentService.getPayment(orderId));

    CompletableFuture<Shipping> shippingFuture = CompletableFuture
        .supplyAsync(() -> shippingService.getStatus(orderId))
        .exceptionally(ex -> Shipping.unknown()); // graceful degradation

    return CompletableFuture.allOf(orderFuture, paymentFuture, shippingFuture)
        .thenApply(v -> new OrderSummary(
            orderFuture.join(),
            paymentFuture.join(),
            shippingFuture.join()
        ))
        .orTimeout(3, TimeUnit.SECONDS)
        .exceptionally(ex -> OrderSummary.partial(orderFuture.getNow(null)))
        .join();
}

// INHERITANCE PROBLEM: Fragile base class
public class InstrumentedHashSet<E> extends HashSet<E> {
    private int addCount = 0;

    @Override
    public boolean add(E e) {
        addCount++;
        return super.add(e);
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        addCount += c.size();
        return super.addAll(c); // BUG: HashSet.addAll() calls add() internally!
    }
    // addAll(3 elements) → addCount = 6 (double counted!)
}

// COMPOSITION FIX: Wrapper/Decorator pattern
public class InstrumentedSet<E> implements Set<E> {
    private final Set<E> delegate; // composition — we don't extend
    private int addCount = 0;

    public InstrumentedSet(Set<E> delegate) {
        this.delegate = delegate;
    }

    public boolean add(E e) {
        addCount++;
        return delegate.add(e); // no internal call loop
    }

    public boolean addAll(Collection<? extends E> c) {
        addCount += c.size();
        return delegate.addAll(c); // delegate handles its own logic
    }
    // Correct! addAll(3 elements) → addCount = 3
}

// Strategy pattern — open for extension, closed for modification
public interface NotificationChannel {
    void send(User user, Message message);
    boolean supports(NotificationType type);
}

public class EmailChannel implements NotificationChannel {
    private final EmailClient client;

    public void send(User user, Message message) {
        client.send(user.getEmail(), message.getSubject(), message.getBody());
    }

    public boolean supports(NotificationType type) {
        return type == NotificationType.TRANSACTIONAL 
            || type == NotificationType.MARKETING;
    }
}

public class SlackChannel implements NotificationChannel {
    private final SlackClient client;

    public void send(User user, Message message) {
        client.postMessage(user.getSlackId(), message.getBody());
    }

    public boolean supports(NotificationType type) {
        return type == NotificationType.ALERT;
    }
}

// Dispatcher — uses composition, new channels auto-discovered via DI
@Service
public class NotificationDispatcher {
    private final List<NotificationChannel> channels;

    public NotificationDispatcher(List<NotificationChannel> channels) {
        this.channels = channels; // Spring injects all implementations
    }

    public void notify(User user, Message message) {
        channels.stream()
            .filter(ch -> ch.supports(message.getType()))
            .forEach(ch -> ch.send(user, message));
    }
}

public final class Money {
    private final BigDecimal amount;
    private final Currency currency;

    public Money(BigDecimal amount, Currency currency) {
        this.amount = amount.setScale(2, RoundingMode.HALF_UP);
        this.currency = Objects.requireNonNull(currency);
    }

    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new CurrencyMismatchException(this.currency, other.currency);
        }
        return new Money(this.amount.add(other.amount), this.currency);
    }

    public Money multiply(int quantity) {
        return new Money(this.amount.multiply(BigDecimal.valueOf(quantity)), this.currency);
    }

    // No setters — thread-safe, can be shared freely, safe as HashMap keys
}