Golang的defer和recover

package main

import "fmt"

func main() {
	fmt.Printf("test1 result %d\n", test1())
	fmt.Printf("test1 result %d\n", test2())
	fmt.Printf("test1 result %d\n", test3())
	fmt.Printf("test1 result %d\n", test4())
}

func test1() int {
	r := 0
	defer func() {
		r = r + 1
	}()
	return r
}

func test2() (r int) {
	r = 0
	defer func() {
		r = r + 1
	}()
	return
}

func test3() (r int) {
	r = 5
	defer func(r int) {
		r = r + 5
	}(r)
	return
}

func test4() (r int) {
	r = 5
	defer func(r int) {
		r = r + 5
	}(r)
	return 1
}

test1 result 0
test1 result 1
test1 result 5
test1 result 1

func test1() (result int) {
    r := 0
    result = r
    func() {
        r = r + 1
    }
    return
}

func test2() (r int) {
    r = 0
	func() {
		r = r + 1
	}()
	return
}

func test3() (r int) {
	r = 5
	func(r int) {
		r = r + 5
	}(r)
	return
}

func test4() (r int) {
	r = 5
    r = 1
	func(r int) {
		r = r + 5
	}(5)  // r在defer定义时的值为5，在return之前才被赋值为1
	return
}

func panic(interface{}) // 触发异常
func recover() interface{} // 捕获异常并处理

package main

import (
	"fmt"
)

var sem chan int = make(chan int)

func main() {
	defer func() {
		if e := recover(); e != nil {
			fmt.Printf("Catch panic: %v\n", e)
		}
	}()
	go t()
	<-sem
	fmt.Println("done")
}

// t is just a test method
// No recover used in this function, so a panic will throw and cause the top function panic and stop
func t() {
	defer func() {
		sem <- 1
	}()
	panic("I'm panic")
}
/** output
 panic不能被main中的defer捕获并处理，导致main也因为panic退出，所以最后的done没有打印出来
panic: I'm panic

goroutine 5 [running]:
main.t()
	/tmp/sandbox093977267/main.go:26 +0x60
created by main.main
	/tmp/sandbox093977267/main.go:15 +0x60
 **/

// runtine/panic.go

// The implementation of the predeclared function recover.
// Cannot split the stack because it needs to reliably
// find the stack segment of its caller.
//
// TODO(rsc): Once we commit to CopyStackAlways,
// this doesn't need to be nosplit.
//go:nosplit
func gorecover(argp uintptr) interface{} {
	// Must be in a function running as part of a deferred call during the panic.
	// Must be called from the topmost function of the call
	// (the function used in the defer statement).
	// p.argp is the argument pointer of that topmost deferred function call.
	// Compare against argp reported by caller.
	// If they match, the caller is the one who can recover.
	gp := getg()
	p := gp._panic
	if p != nil && !p.recovered && argp == uintptr(p.argp) {
		p.recovered = true
		return p.arg
	}
	return nil
}

// runtine/panic.go

// The implementation of the predeclared function panic.
func gopanic(e interface{}) {
	gp := getg()
	// ...

	for {
		d := gp._defer
		if d == nil {
			break
		}

		// ...
        
        gp._defer = d.link
        
        // ...
        
		pc := d.pc
		sp := unsafe.Pointer(d.sp) // must be pointer so it gets adjusted during stack copy
		freedefer(d)
		if p.recovered {
			atomic.Xadd(&runningPanicDefers, -1)

			gp._panic = p.link
            
            // ...
            
			// Pass information about recovering frame to recovery.
			gp.sigcode0 = uintptr(sp)
			gp.sigcode1 = pc
			mcall(recovery)
			throw("recovery failed") // mcall should not return
		}
	}

	// ...
}

 // runtime/panic.go
 
 

// Create a new deferred function fn with siz bytes of arguments.
// The compiler turns a defer statement into a call to this.
//go:nosplit
func deferproc(siz int32, fn *funcval) { // arguments of fn follow fn
	if getg().m.curg != getg() {
		// go code on the system stack can't defer
		throw("defer on system stack")
	}

	// the arguments of fn are in a perilous state. The stack map
	// for deferproc does not describe them. So we can't let garbage
	// collection or stack copying trigger until we've copied them out
	// to somewhere safe. The memmove below does that.
	// Until the copy completes, we can only call nosplit routines.
	sp := getcallersp()
	argp := uintptr(unsafe.Pointer(&fn)) + unsafe.Sizeof(fn)
	callerpc := getcallerpc()

	d := newdefer(siz)
	if d._panic != nil {
		throw("deferproc: d.panic != nil after newdefer")
	}
	d.fn = fn
	d.pc = callerpc
	d.sp = sp
    
	// ...

	// deferproc returns 0 normally.
	// a deferred func that stops a panic
	// makes the deferproc return 1.
	// the code the compiler generates always
	// checks the return value and jumps to the
	// end of the function if deferproc returns != 0.
	return0()
	// No code can go here - the C return register has
	// been set and must not be clobbered.
}

// runtine/panic.go
 
// Run a deferred function if there is one.
// The compiler inserts a call to this at the end of any
// function which calls defer.
// If there is a deferred function, this will call runtime·jmpdefer,
// which will jump to the deferred function such that it appears
// to have been called by the caller of deferreturn at the point
// just before deferreturn was called. The effect is that deferreturn
// is called again and again until there are no more deferred functions.
// Cannot split the stack because we reuse the caller's frame to
// call the deferred function.

// The single argument isn't actually used - it just has its address
// taken so it can be matched against pending defers.
//go:nosplit
func deferreturn(arg0 uintptr) {
	gp := getg()
	d := gp._defer
	if d == nil {
		return
	}

	// ...
    
	fn := d.fn
	d.fn = nil
	gp._defer = d.link
	freedefer(d)
	jmpdefer(fn, uintptr(unsafe.Pointer(&arg0)))
}