Unit 11: Exceptions, Assertions & Multithreading

Opening Hook — When 10 Lakh Orders Hit Zerodha at 9:15 AM

Learning Outcomes — Bloom's Taxonomy Mapped

Concept Explanation — Exceptions, Assertions & Multithreading

📛 PART A: Exception Handling

Think of exceptions like this: You're withdrawing ₹5,000 from an ATM. What could go wrong? Insufficient balance, network failure, card expired, ATM out of cash. Each of these is an exception — an abnormal condition that disrupts normal program flow. Java doesn't crash when these happen — it catches them and responds gracefully.

1. Exception Hierarchy in Java

Java organises all errors and exceptions into a class hierarchy rooted at Throwable. Understanding this tree is the foundation of exception handling.

Hierarchy
                    Throwable
                   /          \
              Error          Exception
             /    \          /          \
    OutOfMemoryError  IOException   RuntimeException
    StackOverflowError SQLException  /        |         \
    VirtualMachineError           NullPointerException
                                  ArrayIndexOutOfBoundsException
                                  ArithmeticException
                                  ClassCastException
                                  IllegalArgumentException

2. try-catch-finally Execution Flow

The try-catch-finally block is Java's mechanism for handling exceptions. Think of it as a safety net under a tightrope walker.

Java
public class ATMWithdrawal {
    public static void main(String[] args) {
        double balance = 5000.0;
        double amount = 7000.0;

        try {
            System.out.println("Attempting withdrawal of ₹" + amount);

            if (amount > balance) {
                throw new ArithmeticException("Insufficient balance!");
            }

            balance -= amount;
            System.out.println("Withdrawal successful. New balance: ₹" + balance);

        } catch (ArithmeticException e) {
            System.out.println("❌ Transaction failed: " + e.getMessage());
            System.out.println("💡 Please deposit more funds or try smaller amount.");

        } finally {
            System.out.println("📋 Transaction log updated. ATM session ended.");
            // This ALWAYS runs — cleanup code goes here
        }
    }
}

Multi-catch (Java 7+): catch(A | B e)

When multiple exceptions need the same handling, use multi-catch to avoid code duplication:

Java
try {
    // Code that might throw different exceptions
    String data = readFromFile("orders.csv");
    int quantity = Integer.parseInt(data);
} catch (IOException | NumberFormatException e) {
    // Single block handles both — DRY principle!
    System.out.println("Error processing order: " + e.getMessage());
    logError(e);
}

try-with-resources (Java 7+): AutoCloseable

Resources like files, database connections, and sockets must be closed after use. Before Java 7, you'd write verbose finally blocks. Now, any class implementing AutoCloseable can be auto-closed:

Java
// ❌ OLD WAY — verbose and error-prone
BufferedReader reader = null;
try {
    reader = new BufferedReader(new FileReader("transactions.csv"));
    String line = reader.readLine();
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (reader != null) {
        try { reader.close(); } catch (IOException e) { /* swallowed */ }
    }
}

// ✅ NEW WAY — clean, safe, automatic
try (BufferedReader reader = new BufferedReader(new FileReader("transactions.csv"))) {
    String line = reader.readLine();
    System.out.println("Transaction: " + line);
} catch (IOException e) {
    System.out.println("Could not read transactions: " + e.getMessage());
}
// reader.close() is called automatically — even if exception occurs!

3. throw vs throws

Java
// 'throws' — declares the method may throw this exception
public void transferMoney(double amount) throws InsufficientBalanceException {
    if (amount > balance) {
        // 'throw' — actually creates and throws the exception
        throw new InsufficientBalanceException("Balance ₹" + balance + " < ₹" + amount);
    }
    balance -= amount;
}

4. Custom Exceptions — InsufficientBalanceException for Paytm

Java's built-in exceptions don't cover business-specific errors. Paytm needs InsufficientBalanceException, Zerodha needs MarketClosedException. You create your own by extending Exception (checked) or RuntimeException (unchecked).

Java — Custom Checked Exception
// Checked — compiler forces caller to handle it
public class InsufficientBalanceException extends Exception {
    private double balance;
    private double amount;

    public InsufficientBalanceException(String message, double balance, double amount) {
        super(message);
        this.balance = balance;
        this.amount = amount;
    }

    public double getBalance() { return balance; }
    public double getAmount()  { return amount; }
    public double getDeficit() { return amount - balance; }
}

Java — Custom Unchecked Exception
// Unchecked — no forced handling (for programming errors)
public class InvalidStockSymbolException extends RuntimeException {
    public InvalidStockSymbolException(String symbol) {
        super("Invalid stock symbol: " + symbol + ". Use NSE/BSE format like RELIANCE, TCS, INFY");
    }
}

Java — Using Custom Exception (Paytm Wallet)
public class PaytmWallet {
    private double balance;
    private String userId;

    public PaytmWallet(String userId, double balance) {
        this.userId = userId;
        this.balance = balance;
    }

    public void pay(String merchant, double amount) throws InsufficientBalanceException {
        if (amount > balance) {
            throw new InsufficientBalanceException(
                "Paytm wallet balance insufficient for " + merchant,
                balance, amount
            );
        }
        balance -= amount;
        System.out.println("✅ ₹" + amount + " paid to " + merchant + ". Balance: ₹" + balance);
    }

    public static void main(String[] args) {
        PaytmWallet wallet = new PaytmWallet("user_mumbai_42", 500.0);
        try {
            wallet.pay("Zomato", 350.0);   // ✅ Success
            wallet.pay("Swiggy", 300.0);   // ❌ Fails — only ₹150 left
        } catch (InsufficientBalanceException e) {
            System.out.println("❌ " + e.getMessage());
            System.out.println("💡 Add ₹" + e.getDeficit() + " to complete this payment.");
        }
    }
}

5. Exception Chaining (initCause)

Sometimes an exception is caused by another exception. Exception chaining preserves the original cause while wrapping it in a more meaningful business exception.

Java
public void processUPIPayment(String upiId, double amount) throws PaymentException {
    try {
        connectToUPIGateway(upiId);   // May throw IOException
        debitAccount(amount);          // May throw SQLException
    } catch (IOException e) {
        PaymentException pe = new PaymentException("UPI gateway unreachable");
        pe.initCause(e);  // Chain the original IOException as root cause
        throw pe;
    } catch (SQLException e) {
        // Alternative: constructor chaining
        throw new PaymentException("Database error during debit", e);
    }
}

// Later, debugging:
catch (PaymentException pe) {
    System.out.println("Payment failed: " + pe.getMessage());
    System.out.println("Root cause: " + pe.getCause().getMessage());
}

6. Assertions — assert Statement & java -ea

Assertions are sanity checks during development. They verify conditions that should always be true. If the condition is false, the JVM throws AssertionError.

Java
public class AssertionDemo {
    public static double calculateDiscount(double price, double discountPercent) {
        assert price >= 0 : "Price cannot be negative: " + price;
        assert discountPercent >= 0 && discountPercent <= 100
            : "Invalid discount: " + discountPercent + "%";

        double finalPrice = price - (price * discountPercent / 100);

        assert finalPrice >= 0 : "Final price went negative!";  // post-condition

        return finalPrice;
    }

    public static void main(String[] args) {
        System.out.println("Price after 20% off: ₹" + calculateDiscount(1000, 20));
        System.out.println("Price after 150% off: ₹" + calculateDiscount(1000, 150));
        // Run with: java -ea AssertionDemo
        // Second call triggers: AssertionError: Invalid discount: 150.0%
    }
}

⚡ PART B: Multithreading

A thread is the smallest unit of execution within a process. When you run a Java program, it starts with one thread (the main thread). Multithreading lets you run multiple threads simultaneously — like Zerodha processing lakhs of buy and sell orders at the same time.

7. Creating Threads — Thread Class vs Runnable Interface

Method 1: Extending Thread Class

Java
class BuyOrderThread extends Thread {
    private String stock;
    private int quantity;

    public BuyOrderThread(String stock, int quantity) {
        this.stock = stock;
        this.quantity = quantity;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() +
            " → BUY " + quantity + " shares of " + stock);
        try { Thread.sleep(1000); } catch (InterruptedException e) { }
        System.out.println(Thread.currentThread().getName() +
            " → Order filled ✅");
    }
}

// Usage:
BuyOrderThread t1 = new BuyOrderThread("RELIANCE", 100);
BuyOrderThread t2 = new BuyOrderThread("TCS", 50);
t1.start();  // DO NOT call run() — call start()!
t2.start();  // Both threads run concurrently

Method 2: Implementing Runnable Interface (Preferred)

Java
class SellOrderRunnable implements Runnable {
    private String stock;
    private int quantity;

    public SellOrderRunnable(String stock, int quantity) {
        this.stock = stock;
        this.quantity = quantity;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() +
            " → SELL " + quantity + " shares of " + stock);
    }
}

// Usage — Runnable is passed TO a Thread object
Thread t3 = new Thread(new SellOrderRunnable("INFY", 200), "SellThread-1");
t3.start();

Method 3: Lambda-based Thread Creation (Java 8+, Cleanest)

Java
// Since Runnable is a @FunctionalInterface with one abstract method (run),
// it can be replaced with a lambda expression:

Thread t4 = new Thread(() -> {
    System.out.println(Thread.currentThread().getName() + " → Processing order via Lambda");
    try { Thread.sleep(500); } catch (InterruptedException e) { }
    System.out.println(Thread.currentThread().getName() + " → Lambda order done ✅");
}, "LambdaThread");
t4.start();

8. Thread Lifecycle — Five States

Lifecycle
  new Thread()         start()         Scheduler picks       run() ends
       |                  |                   |                    |
   [NEW] ──────────> [RUNNABLE] ──────────> [RUNNING] ──────────> [TERMINATED]
                          ↑                   |
                          |                   | sleep()/wait()/
                          |                   | blocked on I/O
                          |                   ↓
                     notify()/            [BLOCKED] /
                     sleep over/          [WAITING] /
                     I/O complete         [TIMED_WAITING]

9. Key Thread Methods

Java — join() Example
public class JoinDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread download = new Thread(() -> {
            System.out.println("📥 Downloading stock data...");
            try { Thread.sleep(2000); } catch (InterruptedException e) { }
            System.out.println("📥 Download complete!");
        });

        download.start();
        download.join();  // Main thread WAITS here until download finishes
        System.out.println("📊 Now processing downloaded data...");
    }
}

10. Synchronization — Preventing Race Conditions

When multiple threads access shared data simultaneously, you get race conditions — unpredictable, incorrect results. Java's synchronized keyword ensures only one thread enters a critical section at a time.

Java — Race Condition (BUG!)
class UnsafeBankAccount {
    private double balance = 10000;

    // ❌ NOT synchronized — two threads can withdraw simultaneously!
    public void withdraw(double amount) {
        if (balance >= amount) {
            // Thread A checks: 10000 >= 8000 ✅
            // Thread B checks: 10000 >= 7000 ✅ (SAME balance!)
            balance -= amount;
            // Both withdraw — balance goes NEGATIVE! ₹-5000
        }
    }
}

Java — Fixed with synchronized
class SafeBankAccount {
    private double balance = 10000;

    // ✅ Synchronized method — only ONE thread can execute at a time
    public synchronized void withdraw(double amount) {
        if (balance >= amount) {
            System.out.println(Thread.currentThread().getName() +
                " withdrawing ₹" + amount);
            balance -= amount;
            System.out.println("Remaining balance: ₹" + balance);
        } else {
            System.out.println(Thread.currentThread().getName() +
                " — Insufficient balance!");
        }
    }

    // ✅ Synchronized block — more granular control
    public void transfer(SafeBankAccount target, double amount) {
        synchronized (this) {  // Lock on source account
            if (balance >= amount) {
                balance -= amount;
                target.deposit(amount);
            }
        }
    }

    public synchronized void deposit(double amount) {
        balance += amount;
    }

    public synchronized double getBalance() {
        return balance;
    }
}

11. wait() / notify() / notifyAll() — Inter-Thread Communication

Sometimes threads need to coordinate. A producer thread creates data, a consumer thread processes it. The consumer must wait when the queue is empty, and the producer must notify the consumer when new data arrives.

Java — Producer-Consumer (Zerodha Order Book)
import java.util.LinkedList;
import java.util.Queue;

public class ZerodhaOrderBook {
    private final Queue<String> orders = new LinkedList<>();
    private final int MAX_CAPACITY = 5;

    // PRODUCER — Traders placing orders
    public synchronized void placeOrder(String order) throws InterruptedException {
        while (orders.size() == MAX_CAPACITY) {
            System.out.println("📋 Order book FULL — " + Thread.currentThread().getName() + " waiting...");
            wait();  // Release lock and wait
        }
        orders.add(order);
        System.out.println("📥 " + Thread.currentThread().getName() + " placed: " + order +
            " [Queue size: " + orders.size() + "]");
        notifyAll();  // Wake up consumers
    }

    // CONSUMER — Matching engine processing orders
    public synchronized String executeOrder() throws InterruptedException {
        while (orders.isEmpty()) {
            System.out.println("⏳ Order book EMPTY — " + Thread.currentThread().getName() + " waiting...");
            wait();  // Release lock and wait
        }
        String order = orders.poll();
        System.out.println("✅ " + Thread.currentThread().getName() + " executed: " + order +
            " [Queue size: " + orders.size() + "]");
        notifyAll();  // Wake up producers
        return order;
    }

    public static void main(String[] args) {
        ZerodhaOrderBook book = new ZerodhaOrderBook();

        // Producer threads (traders)
        Thread trader1 = new Thread(() -> {
            String[] stocks = {"BUY RELIANCE 100", "BUY TCS 50", "SELL INFY 200"};
            for (String s : stocks) {
                try {
                    book.placeOrder(s);
                    Thread.sleep(300);
                } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
            }
        }, "Trader-Ravi");

        Thread trader2 = new Thread(() -> {
            String[] stocks = {"SELL HDFC 75", "BUY WIPRO 150", "BUY SBI 300"};
            for (String s : stocks) {
                try {
                    book.placeOrder(s);
                    Thread.sleep(200);
                } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
            }
        }, "Trader-Priya");

        // Consumer thread (matching engine)
        Thread engine = new Thread(() -> {
            for (int i = 0; i < 6; i++) {
                try {
                    book.executeOrder();
                    Thread.sleep(500);
                } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
            }
        }, "MatchEngine");

        trader1.start();
        trader2.start();
        engine.start();
    }
}

12. Deadlock — Detection & Prevention

Deadlock occurs when two or more threads are permanently blocked, each waiting for a lock held by the other. It's a Mexican standoff — neither can proceed.

Deadlock
Thread A: Locks Account1 → wants Account2 (BLOCKED — B has it)
Thread B: Locks Account2 → wants Account1 (BLOCKED — A has it)

Both waiting forever → DEADLOCK! 💀

Java — Deadlock Prevention via Lock Ordering
public void safeTransfer(SafeBankAccount from, SafeBankAccount to, double amount) {
    // Always lock the account with the smaller ID first
    SafeBankAccount first  = from.getId() < to.getId() ? from : to;
    SafeBankAccount second = from.getId() < to.getId() ? to : from;

    synchronized (first) {
        synchronized (second) {
            if (from.getBalance() >= amount) {
                from.withdraw(amount);
                to.deposit(amount);
            }
        }
    }
}

13. Thread Pools — ExecutorService

Creating a new thread for every task is expensive. Thread pools reuse a fixed set of threads, queuing tasks when all threads are busy. This is how Zerodha handles 10 lakh concurrent requests with far fewer actual threads.

Java
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ZerodhaThreadPool {
    public static void main(String[] args) {
        // Create a pool of 4 threads — reused for all orders
        ExecutorService pool = Executors.newFixedThreadPool(4);

        String[] orders = {
            "BUY RELIANCE 100", "SELL TCS 50", "BUY INFY 200",
            "SELL HDFC 75", "BUY WIPRO 150", "SELL SBI 300",
            "BUY BHARTIARTL 80", "SELL HCLTECH 120"
        };

        for (String order : orders) {
            pool.submit(() -> {
                System.out.println(Thread.currentThread().getName() + " → Processing: " + order);
                try { Thread.sleep(500); } catch (InterruptedException e) { }
                System.out.println(Thread.currentThread().getName() + " → Completed: " + order + " ✅");
            });
        }

        pool.shutdown();  // No new tasks accepted; existing tasks complete
        System.out.println("All orders submitted to pool.");
    }
}

14. Full Code: FileReaderWithResources

Java
import java.io.*;

public class FileReaderWithResources {
    public static void main(String[] args) {
        String filename = "transactions.csv";

        // try-with-resources — auto-closes reader
        try (BufferedReader reader = new BufferedReader(new FileReader(filename))) {
            String line;
            int lineNum = 0;
            System.out.println("📄 Reading " + filename + "...");

            while ((line = reader.readLine()) != null) {
                lineNum++;
                System.out.println("  Line " + lineNum + ": " + line);
            }

            System.out.println("✅ Total lines read: " + lineNum);

        } catch (FileNotFoundException e) {
            System.out.println("❌ File not found: " + filename);
            System.out.println("💡 Create the file or check the path.");
        } catch (IOException e) {
            System.out.println("❌ Error reading file: " + e.getMessage());
        }
        // reader.close() is automatically called here — even if exception occurred!
    }
}

15. Full Code: BankTransferThreads

Java
public class BankTransferThreads {
    static class Account {
        private final int id;
        private double balance;

        public Account(int id, double balance) {
            this.id = id;
            this.balance = balance;
        }

        public int getId() { return id; }
        public double getBalance() { return balance; }

        public void deposit(double amt) { balance += amt; }

        public void withdraw(double amt) throws InsufficientBalanceException {
            if (amt > balance) {
                throw new InsufficientBalanceException(
                    "Account " + id + ": ₹" + balance + " < ₹" + amt, balance, amt);
            }
            balance -= amt;
        }
    }

    public static void safeTransfer(Account from, Account to, double amount) {
        // Lock ordering by account ID to prevent deadlock
        Account first  = from.getId() < to.getId() ? from : to;
        Account second = from.getId() < to.getId() ? to : from;

        synchronized (first) {
            synchronized (second) {
                try {
                    from.withdraw(amount);
                    to.deposit(amount);
                    System.out.println("✅ " + Thread.currentThread().getName() +
                        ": ₹" + amount + " transferred from Acc-" + from.getId() +
                        " to Acc-" + to.getId());
                } catch (InsufficientBalanceException e) {
                    System.out.println("❌ " + Thread.currentThread().getName() +
                        ": " + e.getMessage());
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Account ravi  = new Account(1001, 50000);
        Account priya = new Account(1002, 30000);

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) safeTransfer(ravi, priya, 5000);
        }, "NEFT-Thread");

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 3; i++) safeTransfer(priya, ravi, 8000);
        }, "UPI-Thread");

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("\n📊 Final Balances:");
        System.out.println("  Ravi  (Acc-1001): ₹" + ravi.getBalance());
        System.out.println("  Priya (Acc-1002): ₹" + priya.getBalance());
    }
}

Learn by Doing — 3-Tier Lab Structure (Zerodha Order Book)

Problem Set — Syntax, Programming, Industry & Interview

Syntax Questions (5)

SQ1. Identify and fix the error in this code:

Java
try {
    int x = 10 / 0;
} catch (Exception e) {
    System.out.println("General");
} catch (ArithmeticException e) {  // ← ERROR!
    System.out.println("Arithmetic");
}

Answer: Compilation error — specific exception (ArithmeticException) must come BEFORE general exception (Exception). Reverse the catch order.

SQ2. What is the output?

Java
System.out.println("A");
try {
    System.out.println("B");
    int x = 10/0;
    System.out.println("C");
} catch(ArithmeticException e) {
    System.out.println("D");
} finally {
    System.out.println("E");
}
System.out.println("F");

Answer: A B D E F — "C" is skipped (exception occurred before it), finally always runs, execution continues after try-catch.

SQ3. Will this compile?

Java
public void readFile() {
    FileReader fr = new FileReader("test.txt");
}

Answer: No — FileReader constructor throws checked FileNotFoundException. Must use try-catch or add throws FileNotFoundException.

SQ4. Spot the bug:

Java
Thread t = new Thread(() -> System.out.println("Hello"));
t.run();  // ← BUG!

Answer: Calling run() executes in the CURRENT thread, not a new one. Must call t.start() to create a new thread.

SQ5. What does assert x > 0 : "Negative!"; do when run with java -ea and x = -5?

Answer: Throws AssertionError with message "Negative!" because the condition x > 0 is false and assertions are enabled.

Programming Questions (8)

PQ1. Write a Java program that takes an array of integers and handles ArrayIndexOutOfBoundsException when accessing an invalid index. Print the exception message and the valid range.

PQ2. Create a BankAccount class with withdraw() that throws a custom InsufficientFundsException. Test with multiple withdrawal attempts in a loop.

PQ3. Write a program using try-with-resources to read a file line by line. Handle FileNotFoundException and IOException separately with meaningful messages.

PQ4. Create two threads: one prints even numbers (2–20) and the other prints odd numbers (1–19). Use Thread.sleep(100) between each print. Observe interleaved output.

PQ5. Implement a Counter class with increment() method. Create 3 threads that each increment the counter 1000 times. First run without synchronized (show bug), then with synchronized (show fix). Print final count.

PQ6. Write a program demonstrating multi-catch: parse an integer from a string and access an array element. Handle NumberFormatException | ArrayIndexOutOfBoundsException in a single catch block.

PQ7. Create a producer-consumer program where a producer adds numbers 1–10 to a shared list, and a consumer removes and prints them. Use wait() and notify().

PQ8. Write a program using ExecutorService.newFixedThreadPool(3) that processes 10 tasks. Each task prints the thread name and a task number with a 500ms delay.

Industry Questions (3) — Paytm Custom Exception Chain

IQ1. Design a Paytm payment exception hierarchy: PaymentException (base) → InsufficientBalanceException, UPITimeoutException, InvalidUPIIdException. Implement exception chaining where UPITimeoutException wraps a java.net.SocketTimeoutException. Write the full implementation with test cases.

IQ2. Zerodha's matching engine processes buy and sell orders concurrently. Design a MatchingEngine class with a thread-safe order book (use synchronized + wait/notify). Handle cases: market closed (throw MarketClosedException), invalid symbol (throw InvalidSymbolException), insufficient margin (throw InsufficientMarginException). Use exception chaining to wrap low-level SQLException in business exceptions.

IQ3. HDFC Bank needs a multithreaded NEFT processing system. Design a system where: (a) 5 customer threads submit NEFT requests, (b) 2 processor threads process them from a shared queue, (c) use ExecutorService for the processor pool, (d) custom exceptions for invalid IFSC code, daily limit exceeded, and beneficiary not found. Write complete code with proper shutdown.

Interview Questions (3)

INT1. "What is the difference between throw and throws? When would you use each in a fintech application like Razorpay?"

Model Answer: throw is used inside a method body to actually throw an exception object (e.g., throw new PaymentException("Gateway timeout")). throws is used in the method signature to declare that the method might throw specified checked exceptions, forcing callers to handle them. In Razorpay, a processPayment() method would declare throws PaymentException, GatewayException in its signature, and internally use throw to create specific exception instances when failures occur.

INT2. "Explain what happens if you call run() instead of start() on a Thread object. How would this affect performance in a system like Zerodha?"

Model Answer: Calling run() executes the method in the CURRENT thread — no new thread is created. It becomes a normal method call. In Zerodha, if you called run() instead of start() for each order, all 10 lakh orders would process sequentially on one thread instead of concurrently. This would turn millisecond execution into hours, making the platform unusable during market opening.

INT3. "How do you prevent deadlock in a banking system where multiple threads transfer money between accounts?"

Model Answer: Use lock ordering — always acquire locks on accounts in a consistent order (e.g., by account number). If Thread A transfers from Acc-1001 to Acc-1002, it locks 1001 first, then 1002. If Thread B transfers from Acc-1002 to Acc-1001, it also locks 1001 first (not 1002). Since both threads acquire locks in the same order, deadlock is impossible. Additionally, use tryLock() with timeout for robustness.

MCQ Assessment Bank — 30 Questions (Bloom's Mapped)

Remember / Identify (Q1–Q6)

Understand / Explain (Q7–Q12)

Apply / Implement (Q13–Q18)

try {
    System.out.print("A");
    throw new RuntimeException();
} catch(RuntimeException e) {
    System.out.print("B");
} finally {
    System.out.print("C");
}
System.out.print("D");

Analyze / Compare (Q19–Q23)

Evaluate / Justify (Q24–Q27)

Create / Design (Q28–Q30)

Short Answer Questions (8)

SA1. Differentiate between checked and unchecked exceptions with two examples each.

Answer: Checked exceptions are verified at compile time — the compiler forces you to handle them using try-catch or declare them with throws. They represent recoverable external conditions. Examples: IOException (file/network I/O failure), SQLException (database error). Unchecked exceptions occur at runtime due to programming bugs — the compiler does NOT force handling. They extend RuntimeException. Examples: NullPointerException (accessing null reference), ArrayIndexOutOfBoundsException (invalid array index). Rule of thumb: checked = external failure (plan for it), unchecked = your bug (fix it).

SA2. Explain the purpose of the finally block. Give a scenario where it is essential.

Answer: The finally block executes always — whether an exception occurs or not, whether it's caught or uncaught. Its purpose is resource cleanup: closing files, database connections, network sockets, or releasing locks. It's essential when reading a bank transaction file: if an exception occurs mid-read, the file handle must still be released. Without finally, the file remains locked, preventing other processes from accessing it. Only System.exit() prevents finally from executing.

SA3. What is try-with-resources? Which interface must a class implement to use it?

Answer: Try-with-resources (Java 7+) automatically closes resources declared in the try header when the block exits — even if an exception occurs. The class must implement AutoCloseable interface (which has a single close() method). Example: try (BufferedReader br = new BufferedReader(new FileReader("data.csv"))) { ... } — br.close() is called automatically. Closeable (which extends AutoCloseable) also works. This eliminates verbose finally cleanup blocks and prevents resource leaks.

SA4. Explain the difference between throw and throws with code examples.

Answer: throw is used inside a method body to actually throw an exception object: throw new InsufficientBalanceException("Low balance");. It can throw one exception at a time. throws is used in the method signature to declare that the method may propagate certain checked exceptions to the caller: void pay(double amt) throws InsufficientBalanceException, IOException. The caller must then handle these exceptions. throw = action (throwing), throws = declaration (warning).

SA5. Describe the five states in a Java thread's lifecycle.

Answer: (1) NEW: Thread object created via new Thread(), but start() not yet called. (2) RUNNABLE: After start() is called — thread is ready to run and waiting for CPU scheduling. (3) BLOCKED: Thread is waiting to acquire a monitor lock to enter a synchronized block. (4) WAITING/TIMED_WAITING: Thread called wait(), join(), or sleep() — it's paused. TIMED_WAITING has a timeout; WAITING waits indefinitely until notify(). (5) TERMINATED: Thread's run() method completed or an unhandled exception killed it. Cannot be restarted.

SA6. What is synchronization? Why is it needed in multithreading?

Answer: Synchronization is a mechanism that ensures only one thread can access a critical section (shared resource) at a time. It's needed to prevent race conditions — when two threads simultaneously read/modify shared data, causing corrupted or inconsistent results. In Java, the synchronized keyword locks a method or block on a monitor object. Example: Two threads withdrawing from the same bank account — without synchronization, both might check balance (₹10,000) simultaneously and both withdraw ₹8,000, leaving the account at -₹6,000 instead of correctly failing the second withdrawal.

SA7. Explain wait() and notify() with a real-world analogy.

Answer: wait() and notify() enable inter-thread communication. wait() pauses the current thread and releases the lock, allowing other threads to work. notify() wakes up one waiting thread; notifyAll() wakes all. Analogy: Think of a restaurant kitchen. The waiter (consumer) wait()s when no orders are ready. The chef (producer) prepares a dish and calls notify() — "Order ready!" The waiter wakes up, picks up the dish. If the kitchen is full (no counter space), the chef wait()s until the waiter picks up dishes and notify()s — "Counter cleared!"

SA8. What is a deadlock? How can it be prevented?

Answer: Deadlock occurs when two or more threads are permanently blocked, each holding a lock the other needs. Example: Thread A locks Account-1 and waits for Account-2; Thread B locks Account-2 and waits for Account-1 — neither can proceed. Prevention strategies: (1) Lock ordering — always acquire locks in a consistent order (e.g., ascending account number). (2) Lock timeout — use tryLock(timeout) instead of indefinite waiting. (3) Avoid nested locks — minimize holding multiple locks. (4) Use concurrent collections — ConcurrentHashMap, BlockingQueue handle synchronization internally.

Long Answer Questions (3)

LA1. Explain the complete exception hierarchy in Java. Differentiate between checked and unchecked exceptions with examples. Describe the execution flow of try-catch-finally with multiple catch blocks. (10 marks)

Answer:

Exception Hierarchy: All exceptions in Java descend from Throwable. It has two branches: Error (unrecoverable JVM-level problems like OutOfMemoryError, StackOverflowError — should NOT be caught) and Exception (recoverable application-level problems). Exception further splits into checked exceptions (like IOException, SQLException) and unchecked exceptions (RuntimeException and its subclasses like NullPointerException, ArithmeticException).

Checked vs Unchecked:

try-catch-finally Execution Flow:

Case 1 — No exception: try block executes fully → catch blocks skipped → finally executes → code after try-catch-finally continues.

Case 2 — Exception caught: try block executes until exception → remaining try code SKIPPED → matching catch block executes → finally executes → code continues.

Case 3 — Exception NOT caught: try block executes until exception → no matching catch → finally STILL executes → exception propagates up the call stack.

Multiple catch blocks: Checked top-to-bottom. First matching catch handles the exception. Important: Specific exceptions MUST come before general ones — otherwise compilation error (unreachable code). Example: catch(FileNotFoundException e) must come before catch(IOException e) because FNFE is a subclass of IOE.

LA2. Describe multithreading in Java. Explain Thread class vs Runnable interface with code examples. Describe the complete thread lifecycle with a diagram. (10 marks)

Answer:

Multithreading is the ability to run multiple threads (lightweight processes) concurrently within a single program. Each thread has its own call stack but shares the process's heap memory. Java supports multithreading natively through the java.lang.Thread class and java.lang.Runnable interface.

Method 1 — Extending Thread:

Java
class MyThread extends Thread {
    public void run() { System.out.println("Thread running: " + getName()); }
}
// Usage: new MyThread().start();

Limitation: Can't extend another class (single inheritance).

Method 2 — Implementing Runnable:

Java
class MyTask implements Runnable {
    public void run() { System.out.println("Task running"); }
}
// Usage: new Thread(new MyTask()).start();

Advantage: Can extend another class + better separation of task from thread mechanism.

Method 3 — Lambda (Java 8+):

Java
new Thread(() -> System.out.println("Lambda thread")).start();

Advantage: Most concise. Best for short, inline tasks.

Thread Lifecycle:

NEW (created, not started) → start() → RUNNABLE (ready for CPU) → scheduled → RUNNING (executing run()) → sleep()/wait()/blocked on lock → BLOCKED/WAITING/TIMED_WAITING → notify()/sleep over/lock acquired → back to RUNNABLE → run() completes → TERMINATED (dead, cannot restart).

Key methods: start() (creates new OS thread), run() (contains thread logic — never call directly), sleep(ms) (pauses), join() (wait for thread to die), interrupt() (signal thread to stop), yield() (hint to give up CPU).

LA3. What is synchronization in Java? Explain synchronized methods and synchronized blocks. Describe the producer-consumer problem with wait() and notify(). How does ExecutorService improve thread management? (10 marks)

Answer:

Synchronization prevents race conditions by ensuring mutual exclusion — only one thread can execute a synchronized section at a time. Java provides two mechanisms:

Synchronized Method: public synchronized void withdraw(double amt) — locks the entire method on the object's intrinsic monitor. When Thread A enters, Thread B must wait at the method entrance.

Synchronized Block: synchronized(lockObject) { ... } — locks only the critical section, not the entire method. More granular, better performance for methods with both synchronized and unsynchronized code.

Producer-Consumer Problem: A classic coordination problem. Producer creates data, Consumer processes it. They share a bounded buffer (queue). Producer must wait() when buffer is full; Consumer must wait() when buffer is empty. When Producer adds data, it calls notifyAll() to wake waiting consumers. When Consumer removes data, it calls notifyAll() to wake waiting producers. Important: always check conditions in a while loop (not if) due to spurious wakeups.

ExecutorService Thread Pools: Creating a new thread per task is expensive (OS overhead). ExecutorService manages a pool of reusable threads. Executors.newFixedThreadPool(n) creates n threads that process submitted tasks from a queue. Benefits: (1) Thread reuse — no creation overhead. (2) Bounded concurrency — won't exhaust system resources. (3) Task queuing — tasks wait when all threads are busy. (4) Graceful shutdown — shutdown() stops accepting new tasks; awaitTermination() waits for completion. In production systems like Zerodha, thread pools handle millions of requests with a small, fixed number of threads.

Lab Programs — Lab 1 & Lab 2

Java — Lab1_ExceptionHandling.java
import java.io.*;

// Custom Checked Exception
class InsufficientBalanceException extends Exception {
    private double balance, amount;

    public InsufficientBalanceException(String msg, double bal, double amt) {
        super(msg);
        this.balance = bal;
        this.amount = amt;
    }
    public double getDeficit() { return amount - balance; }
}

public class Lab1_ExceptionHandling {

    // 'throws' — declares this method may throw a checked exception
    public static void withdraw(double balance, double amount)
            throws InsufficientBalanceException {

        // 'assert' — internal sanity check (enable with java -ea)
        assert balance >= 0 : "Balance cannot be negative: " + balance;
        assert amount > 0  : "Withdrawal amount must be positive: " + amount;

        if (amount > balance) {
            // 'throw' — actually throws the exception
            throw new InsufficientBalanceException(
                "Cannot withdraw ₹" + amount + " from balance ₹" + balance,
                balance, amount
            );
        }
        System.out.println("✅ Withdrawn ₹" + amount + ". Remaining: ₹" + (balance - amount));
    }

    public static void readFile(String filename) {
        // try-with-resources — auto-closes the reader
        try (BufferedReader br = new BufferedReader(new FileReader(filename))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println("  📄 " + line);
            }
        } catch (FileNotFoundException e) {
            System.out.println("  ❌ File not found: " + filename);
        } catch (IOException e) {
            System.out.println("  ❌ IO Error: " + e.getMessage());
        }
    }

    public static void main(String[] args) {
        System.out.println("=== PART 1: try-catch-finally ===");

        // 'try' — wraps risky code
        try {
            int result = 100 / 0;
            System.out.println("Result: " + result);  // Never reached
        }
        // 'catch' — handles specific exception
        catch (ArithmeticException e) {
            System.out.println("❌ Caught: " + e.getMessage());
        }
        // 'finally' — ALWAYS executes
        finally {
            System.out.println("📋 Finally block executed (cleanup).");
        }

        System.out.println("\n=== PART 2: throw & throws (Custom Exception) ===");
        try {
            withdraw(5000, 3000);  // ✅ Success
            withdraw(2000, 5000);  // ❌ Throws exception
        } catch (InsufficientBalanceException e) {
            System.out.println("❌ " + e.getMessage());
            System.out.println("💡 Deficit: ₹" + e.getDeficit());
        }

        System.out.println("\n=== PART 3: Multi-catch ===");
        try {
            String str = null;
            System.out.println(str.length());
        } catch (NullPointerException | ArithmeticException e) {
            System.out.println("❌ Multi-catch: " + e.getClass().getSimpleName());
        }

        System.out.println("\n=== PART 4: try-with-resources ===");
        readFile("nonexistent.txt");

        System.out.println("\n=== PART 5: Assertions (run with java -ea) ===");
        int age = -5;
        assert age >= 0 : "Age cannot be negative: " + age;
        System.out.println("Age: " + age);  // Only reached if assertion passes
    }
}

Java — Lab2_MultithreadingLambda.java
public class Lab2_MultithreadingLambda {

    // Shared counter to demonstrate race condition + fix
    private static int counter = 0;
    private static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {

        // ===== PART 1: Thread creation via Lambda =====
        System.out.println("=== PART 1: Lambda Thread Creation ===");

        // Method 1: Lambda with Runnable
        Thread buyThread = new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("🟢 " + Thread.currentThread().getName() +
                    " → BUY Order #" + i);
                try { Thread.sleep(200); } catch (InterruptedException e) { }
            }
        }, "BuyThread");

        Thread sellThread = new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("🔴 " + Thread.currentThread().getName() +
                    " → SELL Order #" + i);
                try { Thread.sleep(300); } catch (InterruptedException e) { }
            }
        }, "SellThread");

        // ===== PART 2: Thread Lifecycle Observation =====
        System.out.println("\n=== PART 2: Thread Lifecycle States ===");
        System.out.println("buyThread state after new:   " + buyThread.getState());  // NEW

        buyThread.start();
        sellThread.start();
        System.out.println("buyThread state after start: " + buyThread.getState());  // RUNNABLE

        Thread.sleep(100);
        System.out.println("buyThread state during run:  " + buyThread.getState());  // TIMED_WAITING (sleeping)

        buyThread.join();   // Main thread waits for buyThread to finish
        sellThread.join();  // Main thread waits for sellThread to finish
        System.out.println("buyThread state after join:  " + buyThread.getState());  // TERMINATED

        // ===== PART 3: Race Condition Demo =====
        System.out.println("\n=== PART 3: Race Condition (WITHOUT sync) ===");
        counter = 0;

        Thread inc1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) counter++;  // NOT synchronized!
        }, "Inc-1");

        Thread inc2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) counter++;
        }, "Inc-2");

        inc1.start(); inc2.start();
        inc1.join();  inc2.join();
        System.out.println("Expected: 20000, Actual: " + counter + " (WRONG — race condition!)");

        // ===== PART 4: Fixed with Synchronized =====
        System.out.println("\n=== PART 4: Fixed (WITH synchronized) ===");
        counter = 0;

        Thread safe1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                synchronized (lock) { counter++; }  // ✅ Synchronized!
            }
        }, "Safe-1");

        Thread safe2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                synchronized (lock) { counter++; }
            }
        }, "Safe-2");

        safe1.start(); safe2.start();
        safe1.join();  safe2.join();
        System.out.println("Expected: 20000, Actual: " + counter + " (CORRECT ✅)");

        // ===== PART 5: Thread with interrupt =====
        System.out.println("\n=== PART 5: Thread Interrupt ===");
        Thread longTask = new Thread(() -> {
            try {
                System.out.println("⏳ Long task started (sleeping 10 sec)...");
                Thread.sleep(10000);
                System.out.println("Long task completed.");
            } catch (InterruptedException e) {
                System.out.println("⚡ Long task INTERRUPTED! Cleaning up...");
            }
        }, "LongTask");

        longTask.start();
        Thread.sleep(1000);
        longTask.interrupt();  // Cancel the long task after 1 sec
        longTask.join();

        System.out.println("\n✅ All multithreading demos complete!");
    }
}

Industry Spotlight — A Day in the Life

Earn With It — Multithreaded Microservices ₹15K–₹50K/month

Chapter Summary — Quick Revision

📱 Code Tweet — Unit 11 in 280 Characters

Earning Checkpoint — Are You Job-Ready?

✅ Unit 11 complete. MCQs: 30. Labs 1, 2 covered. Ready for Unit 12!

[QR: Link to EduArtha video tutorial — Java Exceptions, Assertions & Multithreading]