How to Dump Goroutine Stacks Without Stopping a Go Process?

Dumping Goroutine Stacks Without Halting Process in Go

Given a running Go process, capturing stack traces for all its goroutines can be achieved without code modifications or process termination. Here's a solution to fulfill the requirements:

Implementation:

1. Signal Handler:

   • Create a channel, sigChan, to receive signals.
   • Start a goroutine to listen for SIGQUIT signals on sigChan.
   • When a signal is received, it formats the stack trace and prints it.

2. Signal Notification:

   • Call signal.Notify(sigChan, syscall.SIGQUIT) to send SIGQUIT signals to sigChan.

3. Stack Trace Dumping:

   • In the signal handler goroutine, call runtime.Stack() to generate the stack trace.
   • Print the generated stack trace.

Example Code:

<code class="go">import (
    "fmt"
    "os"
    "os/signal"
    "runtime"
    "syscall"
)

func main() {
    // Create a channel to receive signals
    sigChan := make(chan os.Signal)

    // Start a goroutine to listen for signals and dump stack traces
    go func() {
        stacktrace := make([]byte, 8192)
        for _ = range sigChan {
            length := runtime.Stack(stacktrace, true)
            fmt.Println(string(stacktrace[:length]))
        }
    }()

    // Notify the process to listen for SIGQUIT signals and send them to sigChan
    signal.Notify(sigChan, syscall.SIGQUIT)

    // Do some other work here...
}</code>

By running this code, you can trigger stack trace dumping by sending SIGQUIT to the Go process without killing it. To do so, use kill -6 , where is the process ID of your Go program. The output will contain the stack traces of all goroutines running within the process.

The above is the detailed content of How to Dump Goroutine Stacks Without Stopping a Go Process?. For more information, please follow other related articles on the PHP Chinese website!