Why can’t the main process catch golang’s panic?

The main process cannot catch Panic that occurs in Go because of asynchronous execution (Goroutine). Workarounds include: using the Recovery function to capture and recover panics. Use the Context package to pass values ​​to Goroutines and log Panic. Use a custom Panic Listener to register a listener in the main function to catch and handle panics.

Why can’t the main process catch Golang’s Panic?

In Go, Panic is a built-in function used when the program encounters an unrecoverable error. It stops program execution and prints an error message. However, in some cases, Panic cannot be caught by the main process.

Cause:

The main reason why the main process cannot catch Panic is asynchronous execution. In Go, Goroutines are lightweight threads that execute in parallel. When a Panic occurs in a Goroutine, the main process won't know immediately because the Goroutine runs on its own stack.

Solution:

In order to solve this problem, there are several methods:

• Use the Recovery function :

  • The Recovery function is a built-in function that allows you to capture and recover from a Panic when it occurs. This method works with Goroutines.

• Using the Context package:

  • The Context package provides a way to pass values ​​to Goroutine. You can use a Context to pass a channel for logging Panic.

• Using Panic Listener:

  • You can use a custom package or library to create a Panic Listener. This method involves registering a listener in the main function, which will catch and handle the Panic when it occurs.

Example:

Example of using the Recovery function to capture Panic:

<code class="go">func main() {
    go func() {
        defer func() {
            if r := recover(); r != nil {
                fmt.Println("Panic recovered:", r)
            }
        }()

        panic("Oops, something bad happened.")
    }()

    time.Sleep(time.Second) // Give the Goroutine time to execute.
}</code>

Use Panic Listener to capture Panic Example:

<code class="go">package main

import (
    "fmt"
    "sync/atomic"
    "time"
)

var panicCount uint64

func main() {
    // 注册 Panic Listener
    runtime.SetPanicOnFault(true)
    runtime.SetTraceback("all")

    // 开启一个 Goroutine 来制造 Panic
    go func() {
        defer func() {
            if r := recover(); r != nil {
                fmt.Println("Panic recovered:", r)
                atomic.AddUint64(&panicCount, 1)
            }
        }()

        panic("Whoops, something bad happened.")
    }()

    time.Sleep(time.Second) // Give the Goroutine time to execute.

    // 检查 Panic 计数
    if panicCount > 0 {
        fmt.Println("Total Panics:", panicCount)
    } else {
        fmt.Println("No Panics occurred.")
    }
}</code>

The above is the detailed content of Why can’t the main process catch golang’s panic?. For more information, please follow other related articles on the PHP Chinese website!