Panic

A built-in function that abruptly terminates the normal execution flow of a goroutine and initiates a panicking sequence. When invoked, it signals an unrecoverable state, halting standard control flow and beginning a systematic unwinding of the call stack.

Syntax

func panic(v any)

The panic function accepts a single argument of type any (the empty interface interface{}). This payload is typically a string or an error type, but can be any arbitrary data structure used to describe the failure state.

Execution Mechanics

When panic is invoked, the Go runtime executes the following sequence:

1. Immediate Halt: Normal sequential execution of the current function stops immediately. Any code below the panic call is unreachable.
2. Deferred Execution: The runtime executes any functions registered via the defer keyword within the current stack frame. These execute in standard LIFO (Last-In, First-Out) order.
3. Stack Unwinding: Once all deferred functions in the current frame complete, the function returns to its caller. To the caller, the invocation behaves as if it were a call to panic.
4. Propagation: This unwinding process bubbles up the call stack frame by frame, executing deferred functions at each level.
5. Program Termination: If the stack unwinds completely to the top of the goroutine without being intercepted, the program crashes. The runtime prints the panic payload v followed by a detailed stack trace to stderr, and exits with a non-zero status code.

Mechanical Visualization

package main

import "fmt"

func main() {
    defer fmt.Println("Main defer: executes second")
    
    execute()
    
    fmt.Println("Unreachable: main execution halted")
}

func execute() {
    defer fmt.Println("Execute defer: executes first")
    
    panic("fatal state encountered")
    
    fmt.Println("Unreachable: execute execution halted")
}

Execution Output:

Execute defer: executes first
Main defer: executes second
panic: fatal state encountered

goroutine 1 [running]:
main.execute()
        /path/to/main.go:16 +0x79
main.main()
        /path/to/main.go:8 +0x78
exit status 2

Goroutine Boundaries

Panics are strictly bound to the goroutine in which they are invoked. If a panic occurs in a spawned goroutine, the stack unwinding is isolated to that specific goroutine’s call stack. However, if the panic reaches the top of that goroutine’s stack without being intercepted, it will crash the entire Go program, regardless of the state of the main goroutine or other concurrent processes.

Interception

The panicking sequence can only be halted by the built-in recover() function. recover() must be called directly within a deferred function. If called during a panicking sequence, recover() captures the payload v passed to panic and stops the stack unwinding.

When a panic is recovered, the function containing the defer statement that called recover() does not resume execution. Any code following the panic or the function call that caused the panic remains unreachable. Instead, the function containing the defer is immediately terminated and returns normally. Execution then resumes in the caller of the function that contained the defer statement.

Master Go with Deep Grasping Methodology!

Learn More