Panic is like a program "heart attack" in Go, recover can be used as a "first aid tool" to prevent crashes, but recover only takes effect in the defer function. 1. recover is used to avoid service lapse, log logs, and return friendly errors. 2. It must be used with defer, and it only takes effect on the same goroutine. The program does not return to the panic point after recovery. 3. It is recommended to use it at the top level or critical entrance, and do not abuse it, and give priority to using error. 4. A common pattern is to encapsulate the logic of safeRun function to wrap possible panics. Only by mastering its usage scenarios and limitations can it play its role correctly.

Panic is like a program that suddenly has a "heart attack" in Go. If it is not processed in time, the entire process may be terminated directly. Fortunately, Go provides recover, a "first aid tool", which allows you to try to stabilize the program after panic occurs and prevent it from crashing.

However, it should be noted that recover can only be effective in the functions called by defer, and not be restored anywhere.

When should I use recover?

panic is not the preferred method for error handling, but it will be triggered in certain serious errors and cannot continue execution. At this time you might think:

• Avoid the entire service lapse (such as when the web server processes the request)
• Grab the exception and record the log to facilitate troubleshooting
• Return a friendly error message instead of a direct crash

At this time, recovery comes in handy. Especially in middleware or global interceptors, recover is often used to catch unexpected panics and provide a bottom-up process.

How to use recover correctly?

There are fixed routines for using recover, and the basic structure is as follows:

 defer func() {
    if r := recover(); r != nil {
        fmt.Println("Recovered in f", r)
    }
}()

A few key points to remember:

• Must be used with defer : recover must be placed in the defer function to be effective.
• It can only be recovered in the same goroutine : If you panic in one goroutine, the other recover cannot be caught.
• After recovering, the program will not return to the panic point : the program will continue to execute subsequent logic after returning from the defer function, and the code after the panic point will not run again.

For example, you accidentally accessed a null pointer when processing an HTTP request. If there is no recovery, the entire service may crash; if you use recovery, you can at least mark this request as a failure and do not affect other requests.

Limitations and considerations of recover

Although recover can save lives, it is not omnipotent, and in some cases it can do nothing:

• Cannot recover across goroutines : If you panic in a child goroutine, the recovery of the main function cannot be seen.
• The stack after recovery has been broken : although the program does not crash, the state may be inconsistent, and subsequent logic needs to be handled with caution.
• Recover should not be abused : it is more like the last line of defense and should not be used instead of normal error checking.

So suggestion:

• Try to use recover only at the top level or at the critical entrance (such as main functions, HTTP handlers)
• It is best to record detailed information after recover to facilitate the location of problems
• For places where errors are known, use error to return instead of relying on panic/recover

Common patterns for writing recover

Many projects will encapsulate a general recovery function, such as this:

 func safeRun(fn func()) {
    defer func() {
        if r := recover(); r != nil {
            log.Printf("Recovered: %v", r)
        }
    }()
    fn()
}

Then call this:

 safeRun(func() {
    // Possible panic code})

This writing method is very practical in concurrent tasks or timed tasks, and can prevent a certain task from crashing and causing overall failure.

Basically that's it. recover is not complicated, but it is easy to use it incorrectly. Only by mastering its usage scenarios and limitations can it truly bring value.

The above is the detailed content of How to recover from a panic in Go?. For more information, please follow other related articles on the PHP Chinese website!