Exception handling and event handling

This week two constructs “outside the normal flow”: exceptions (what happens when something goes wrong?) and events (what runs when something happens?). The common idea in both: there is a handler that runs not in the order you wrote it but triggered by an occurrence. On exams, tracing the try/catch/finally flow and language design comparisons come up most.

Golden rules:

1. When an exception is thrown, the rest of the try block is skipped.
2. Catches are tried from top to bottom, the first match wins.
3. finally runs in every case, even with a return.
4. If there is no local handler, the exception propagates to the caller.
5. In Java a checked exception is either caught or declared.

What is an exception?

An exception is an unusual event detected by hardware or software that requires special processing: division by zero, array bounds violation, file not found. The code that handles an exception is called an exception handler. The occurrence of an exception is called raise (throw in Java).

In a language without exception support, how is an error reported? A function returns a special value (an error code) or writes a status to a parameter. The problem: you need to check after every call, the code becomes unreadable, and forgetting to check is easy. Language support separates this: normal code in one place, error handling in another.

Design questions

Continuation: where does control go after the handler finishes? The resumption model returns to where the exception occurred. The termination model does not return; it continues after the construct containing the handler. Java, C++, Ada, C#: termination.

The flow in Java

try {
    System.out.print("1 ");
    int[] x = new int[2];
    x[5] = 1;                    // exception: the rest is skipped
    System.out.print("2 ");
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.print("3 ");
} finally {
    System.out.print("4 ");
}
System.out.println("5");

1 3 4 5

finally and return

static int f() { try { return 1; } finally { System.out.print("fin "); } }
static int g() { try { return 1; } finally { return 2; } }
static int h() { int x = 10; try { return x; } finally { x = 20; } }

fin 1
2
10

finally runs after the return in try but before the method returns. In g, the return of finally overrides. In h, the return value was saved at the moment of return x; changing x afterward does not affect it.

Propagation

static void c(int n) { System.out.print("c" + n + " ");
    if (n == 0) throw new IllegalStateException("zero"); }
static void b(int n) {
    try { c(n); System.out.print("b-after "); }
    catch (IllegalArgumentException e) { System.out.print("b-catch "); }
    finally { System.out.print("b-fin "); }
}
static void a(int n) {
    try { b(n); }
    catch (RuntimeException e) { System.out.print("a-catch:" + e.getMessage() + " "); }
}
// a(1); a(0);

c1 b-after b-fin 
c0 b-fin a-catch:zero 

Tracing recipe: where was the exception born? Is there a matching catch in that function? If not, run the finally blocks and go up to the next caller, and ask the same question.

Class hierarchy: checked and unchecked

Throwable
├── Error                  (JVM errors: OutOfMemoryError)      unchecked
└── Exception                                                   checked
    ├── IOException → FileNotFoundException                     checked
    └── RuntimeException                                        unchecked
        ├── ArithmeticException, NullPointerException
        ├── ArrayIndexOutOfBoundsException, ClassCastException
        └── IllegalArgumentException → NumberFormatException

For checked exceptions the compiler requires one of two options: catch it inside the method, or declare it in the header with throws. The unchecked ones (subclasses of RuntimeException and Error) can occur anywhere, so no declaration is required.

static void read() { throw new java.io.IOException("disk"); }
error: unreported exception IOException; must be caught or declared to be thrown

The catch order must be from specific to general; otherwise the catch below can never be reached and the compiler gives an error:

catch (IOException e) { } catch (FileNotFoundException e) { }
error: exception FileNotFoundException has already been caught

User-defined exception

static class InsufficientFunds extends Exception { InsufficientFunds(String m) { super(m); } }
static void withdraw(int bal, int amt) throws InsufficientFunds {
    if (amt > bal) throw new InsufficientFunds("need " + (amt - bal));
}
try { withdraw(50, 80); } catch (InsufficientFunds e) { System.out.println("caught " + e.getMessage()); }

caught need 30

Rethrowing from inside a handler

try {
    try { throw new RuntimeException("inner"); }
    catch (RuntimeException e) { System.out.print("handle "); throw new IllegalArgumentException("outer"); }
    finally { System.out.print("fin "); }
} catch (IllegalArgumentException e) { System.out.println("rethrown " + e.getMessage()); }

handle fin rethrown outer

Language comparison

In Ada, if an exception is not handled in a block, it propagates to the unit containing the block; if it is in a subprogram, to the caller. In C++, when an exception is thrown, as the stack unwinds the destructors of local objects are called, and resources are freed this way.

Event handling

An event is a notification that something happened: a button click, a key press, a timer expiring, data arriving from the network. An event handler is the code that runs in response to the event. The difference from an exception: events are ordinary, expected things, they are the actual job of the program. GUIs and web pages work event-driven: the program waits for events, and when an event arrives, it calls the relevant handler.

The listener model (Java)

The event source keeps a list of the objects listening to it. When the event occurs it calls the handler method of all of them. In Swing, button.addActionListener(listener) and actionPerformed(ActionEvent e).

interface Listener { void on(String e); }
static class Button {
    List<Listener> ls = new ArrayList<>();
    void add(Listener l) { ls.add(l); }
    void click() { for (Listener l : ls) l.on("click"); }
}
Button btn = new Button(); StringBuilder log = new StringBuilder();
btn.add(e -> log.append("A:" + e + " "));
btn.add(e -> log.append("B "));
btn.click(); btn.click();
System.out.println(log.toString().trim());

A:click B A:click B

In C# the same idea is built into the language with delegates and the event keyword: button.Click += handler;.

The JavaScript event loop

The browser and Node.js run an event loop on a single thread. First the synchronous code finishes; then microtasks (promise callbacks); then the tasks in the event queue (timers, clicks).

const out = [];
setTimeout(() => out.push("timeout"), 0);
Promise.resolve().then(() => out.push("promise"));
out.push("sync1");
queueMicrotask(() => out.push("micro"));
out.push("sync2");
setTimeout(() => console.log(out.join(" ")), 10);

sync1 sync2 promise micro timeout

Node’s EventEmitter is the same as the listener model: handlers run in registration order, synchronously; one added with once removes itself after the first event.

first 1 | once 1 | third | first 2 | third

Common mistakes

try {
    System.out.print("1 ");
    int[] x = new int[2];
    x[5] = 1;
    System.out.print("2 ");
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.print("3 ");
} finally {
    System.out.print("4 ");
}
System.out.println("5");

static int f() { try { return 1; } finally { System.out.print("fin "); } }
static int g() { try { return 1; } finally { return 2; } }

static int h() {
    int x = 10;
    try { return x; }
    finally { x = 20; }
}

static void c(int n) { System.out.print("c" + n + " ");
    if (n == 0) throw new IllegalStateException("zero"); }
static void b(int n) {
    try { c(n); System.out.print("b-after "); }
    catch (IllegalArgumentException e) { System.out.print("b-catch "); }
    finally { System.out.print("b-fin "); }
}
static void a(int n) {
    try { b(n); }
    catch (RuntimeException e) { System.out.print("a-catch:" + e.getMessage() + " "); }
}

try { throw new java.io.FileNotFoundException(); }
catch (java.io.IOException e) { }
catch (java.io.FileNotFoundException e) { }

static void read() { throw new java.io.IOException("disk"); }

int count = 0;
for (String s : new String[]{"12", "x", "7", ""}) {
    try { count += Integer.parseInt(s); }
    catch (NumberFormatException e) { count += 100; }
}
System.out.println(count);

try {
    try { throw new RuntimeException("inner"); }
    catch (RuntimeException e) {
        System.out.print("handle ");
        throw new IllegalArgumentException("outer");
    }
    finally { System.out.print("fin "); }
} catch (IllegalArgumentException e) {
    System.out.println("rethrown " + e.getMessage());
}

setTimeout(() => out.push("timeout"), 0);
Promise.resolve().then(() => out.push("promise"));
out.push("sync1");
queueMicrotask(() => out.push("micro"));
out.push("sync2");