Explain Panic/Recover Mechanism in Detail

In Go, a function call may undergo an exiting phase before it fully exits. In the exiting phase, the deferred function calls pushed into the deferred call queue during executing the function call will be executed (in the inverse pushing order). When all of the deferred calls fully exit, the exiting phase ends and the function call also fully exits.

Exiting phases might also be called returning phases elsewhere.

A function call may enter its exiting phase (or exit directly) through three ways:

1. after the call returns normally.
2. when a panic occurs in the call.
3. after the runtime.Goexit function is called and fully exits in the call.

For example, in the following code snippet,

• a call to the function f0 or f1 will enter its existing phase after it returns normally.
• a call to the function f2 will enter its exiting phase after the divided-by-zero panic happens.
• a call to the function f3 will enter its exiting phase after the runtime.Goexit function call fully exits.

import (
	"fmt"
	"runtime"
)

func f0() int {
	var x = 1
	defer fmt.Println("exits normally:", x)
	x++
	return x
}

func f1() {
	var x = 1
	defer fmt.Println("exits normally:", x)
	x++
}

func f2() {
	var x, y = 1, 0
	defer fmt.Println("exits for panicking:", x)
	x = x / y // will panic
	x++       // unreachable
}

func f3() int {
	x := 1
	defer fmt.Println("exits for Goexiting:", x)
	x++
	runtime.Goexit()
	return x+x // unreachable
}

BTW, the runtime.Goexit() function is not intended to be called in the main goroutine of a program.

When a panic occurs directly in a function call, we say the (unrecovered) panic starts associating with the function call. Associating a panic with a function call will make the function call enter its exiting phase immediately.

A runtime.Goexit call will produce a Goexit signal and associate the signal with the call. We can view a Goexit signal as a special panic and call Goexit signals as Goexit panics sometimes below. Goexit panics act the same as general panics in some ways, but there are also two differences:

1. Goexit panics are unrecoverable.
2. Goexit panics are harmless. They don't lead to program crashing.

At any given time during program running, a function call may associate with at most one unrecovered panic, which may be a general panic or a Goexit signal. When a function call is invoked, there is not a panic associating with the call initially, no matter whether its caller (the nesting call) has entered exiting phase or not. Surely, panics might occur later in the process of executing the function call, so a panic might associate with the function call later.

If a call is associating with an unrecovered panic, then

• the call will associate with no panics when the unrecovered panic is recovered.
• when a new panic occurs in the function call, the new one will replace the old one to act as the associating unrecovered panic of the function call.

For example, in the following program, the recovered panic is panic 3, which is the last panic associating with the main function call.

package main

import "fmt"

func main() {
	defer func() {
		fmt.Println(recover()) // 3
	}()
	
	defer panic(3) // will replace panic 2
	defer panic(2) // will replace panic 1
	defer panic(1) // will replace panic 0
	panic(0)
}

Although it is unusual, there might be multiple unrecovered panics coexisting in a goroutine at a time. Each one associates with one non-exited function call in the call stack of the goroutine. When a nested call fully exits and it still associates with an unrecovered panic, the unrecovered panic will spread to the nesting call (the caller of the nested call). The effect is the same as a panic occurs directly in the nesting call. That says,

• if there was an old unrecovered panic associating with the nesting call before, the old one will be replaced by the spread one. For this case, the nesting call must had already entered its exiting phase for sure, so the next deferred function call in its deferred call queue will be invoked.
• if there was not an unrecovered panic associating with the nesting call before, the spread one will associates with the nesting call. For this case, the nesting call might have entered its exiting phase or not. If it hasn't, it will enter its exiting phase immediately.

So, when a goroutine finishes to exit, there may be at most one unrecovered panic in the goroutine. If a goroutine exits with an unrecovered panic and the unreovered panic is not a Goexit panic, the whole program crashes, and the information of the unrecovered panic will be reported. Otherwise, the goroutine exits normally (peacefully). This is why we say Goexit panics are harmless.

The following example program will crash when it runs, because the panic 2 is still not recovered when the new goroutine exits.

package main

func main() {
	// The new goroutine.
	go func() {
		// This is an anonymous deferred call.
		// When it fully exits, the panic 2 will spread
		// to the entry function call of the new
		// goroutine, and replace the panic 0. The
		// panic 2 will never be recovered.
		defer func() {
			// As explained in the last example,
			// panic 2 will replace panic 1.
			defer panic(2)
			
			// When the anonymous function call fully
			// exits, panic 1 will spread to (and
			// associate with) the nesting anonymous
			// deferred call.
			func () {
				// Once the panic 1 occurs, there will
				// be two unrecovered panics coexisting
				// in the new goroutine. One (panic 0)
				// associates with the entry function
				// call of the new goroutine, the other
				// (panic 1) associates with the
				// current anonymous function call.
				panic(1)
			}()
		}()
		panic(0)
	}()
	
	select{}
}

The output (when the above program is compiled with the standard Go compiler v1.22.n):

panic: 0
	panic: 1
	panic: 2

...

The format of the output is not perfect, it is prone to make some people think that the panic 0 is the final unrecovered panic, whereas the final unrecovered panic is actually panic 2.

The following program will exit normally when it runs. The runtime.Goexit call in the end acts as an ultimate recover operation.

package main

import "runtime"

func f() {
	// The Goexit signal replaces the "bye"
	// panic as the final (harmless) panic.
	defer runtime.Goexit()
	panic("bye")
}

func main() {
	go f()
	
	for runtime.NumGoroutine() > 1 {
		runtime.Gosched()
	}
}

The builtin recover function must be called at proper places to take effect. Otherwise, the call is a no-ops. For example, none of the recover calls in the following example recover the bye panic.

package main

func main() {
	defer func() {
		defer func() {
			recover() // no-op
		}()
	}()
	defer func() {
		func() {
			recover() // no-op
		}()
	}()
	func() {
		defer func() {
			recover() // no-op
		}()
	}()
	func() {
		defer recover() // no-op
	}()
	func() {
		recover() // no-op
	}()
	recover()       // no-op
	defer recover() // no-op
	panic("bye")
}

We have already known that the following recover call takes effect.

package main

func main() {
	defer func() {
		recover() // take effect
	}()

	panic("bye")
}

Then why don't those recover calls in the first example of the current section take effect? Let's read the current version of Go specification:

There is an example showing the first condition case in the last article.

Most of the recover calls in the first example of the current section satisfy either the second or the third conditions mentioned in Go specification, except the first call. Yes, here, the current descriptions are not precise yet. The third condition should be described as

• recover was not called directly by a deferred function call which was called directly by the function call associating with the expected to-be-recovered panic.

In the first example of the current section, the expected to-be-recovered panic is associating with the main function call. The first recover call is called directly by a deferred function call but the deferred function call is not called directly by the main function call. This is why the first recover call is a no-op.

In fact, the current Go specification also doesn't explain well why the second recover call (by code line order), which is expected to recover panic 1, in the following example doesn't take effect.

// This program exits without recovering panic 1.
package main

func demo() {
	defer func() {
		defer func() {
			recover() // this one recovers panic 2
		}()

		defer recover() // no-op

		panic(2)
	}()
	panic(1)
}

func main() {
	demo()
}

What Go specification doesn't mention is that, each recover call is viewed as an attempt to recover the newest unrecovered panic in the current goroutine. Surely, if the newest unrecovered panic doesn't exist or it is an unrecoverable Goexit signal, then that recover call is a no-op.

Go runtime thinks the second recover call in the above example attempts to recover the newest unrecovered panic, panic 2, which is associating with the caller call of the second recover call. The second recover call is not called directly by a deferred function call which is called by the associating function call. Instead, it is directly called by the associating function call. This is why the second recover call is a no-op.

OK, now, let's try to make a short description on which recover calls will take effect:

• About Go 101 - why this book is written.
• Acknowledgments

• An Introduction of Go - why Go is worth learning.
• The Go Toolchain - how to compile and run Go programs.

• Become Familiar With Go Code
  • Introduction of Source Code Elements
  • Keywords and Identifiers
  • Basic Types and Their Value Literals
  • Constants and Variables - also introduces untyped values and type deductions.
  • Common Operators - also introduces more type deduction rules.
  • Function Declarations and Calls
  • Code Packages and Package Imports
  • Expressions, Statements and Simple Statements
  • Basic Control Flows
  • Goroutines, Deferred Function Calls and Panic/Recover

• Go Type System
  • Go Type System Overview - a must read to master Go programming.
  • Pointers
  • Structs
  • Value Parts - to gain a deeper understanding into Go values.
  • Arrays, Slices and Maps - first-class citizen container types.
  • Strings
  • Functions - function types and values, including variadic functions.
  • Channels - the Go way to do concurrency synchronizations.
  • Methods
  • Interfaces - value boxes used to do reflection and polymorphism.
  • Type Embedding - type extension in the Go way.
  • Type-Unsafe Pointers
  • Generics - use and read composite types
  • Reflections - the reflect standard package.

• Some Special Topics
  • Line Break Rules
  • More About Deferred Function Calls
  • Some Panic/Recover Use Cases
  • Explain Panic/Recover Mechanism in Detail - also explains exiting phases of function calls.
  • Code Blocks and Identifier Scopes
  • Expression Evaluation Orders
  • Value Copy Costs in Go
  • Bounds Check Elimination

• Concurrent Programming
  • Concurrency Synchronization Overview
  • Channel Use Cases
  • How to Gracefully Close Channels
  • Other Concurrency Synchronization Techniques - the sync standard package.
  • Atomic Operations - the sync/atomic standard package.
  • Memory Order Guarantees in Go
  • Common Concurrent Programming Mistakes

• Memory Related
  • Memory Blocks
  • Memory Layouts
  • Memory Leaking Scenarios

• Some Summaries
  • Some Simple Summaries
  • nil in Go
  • Value Conversion, Assignment and Comparison Rules
  • Syntax/Semantics Exceptions
  • Go FAQ 101

• More Go Related Topics