Recover in Go

recover lets an appropriately deferred function stop a panic during stack unwinding, often at a well-defined boundary.

Call recover() directly within a deferred function running in the same goroutine as the panic. If it successfully recovers, the panicking function does not resume after the panic site; it returns to its caller.

Recovery can be useful in a top-level worker boundary that turns unexpected panics into controlled failures and records diagnostic information. It should not be used to silently hide errors or replace routine error checking.

Follow this diagram before executing the example. Check where a value or decision changes what runs next.

This example is a complete program. Save it as main.go or paste it into the Go Playground.

Go code

package main

import "fmt"

func run() {
	defer func() {
		if problem := recover(); problem != nil {
			fmt.Println("Handled:", problem)
		}
	}()
	panic("problem in task")
}
func main() {
	run()
	fmt.Println("Program continues")
}

Output

Handled: problem in task
Program continues

The deferred function receives the panic value and handles it. After run returns, main proceeds and prints Program continues.

• A recover call outside the appropriate deferred panic path does not stop the panic.
• recover does not let the program continue from the statement immediately after the panic.

Add a print before the panic and another immediately after it. Predict which one never executes.

Tip: Edit the example above, predict the output, and run the modified code to test your reasoning.

You have practiced Recover in Go in a small, self-contained program. The important habit is to predict what runs, inspect the actual output and distinguish the language rule from the particular example.

Before continuing, make sure you can explain the program to someone who has not seen it, including the line that changes its result.