How golang performs the shutdown operation of goroutine

Golang is an elegant programming language because it provides easy concurrency. Concurrency is at the core of all modern software development, allowing us to build applications that are highly scalable, maintainable, and reliable. In Golang, it is very easy to achieve concurrency through goroutine, but the use of goroutine may also cause some problems, the most common of which is how to perform the shutdown operation of goroutine.

In this article, we will explore how to shut down goroutine gracefully in Golang. We will introduce two methods, one is to use a channel to send a signal to close and the other is to use the WithCancel function of the context package to cancel the goroutine. At the same time, we will also explore how to avoid the problem of goroutine leaks.

Use channel to close goroutine

First, let’s take a look at how to use channel to close goroutine. Channels are the basic structure used for communication in Golang. Channels can be used not only to transfer data, but also to transfer control signals.

We can create a channel to control the closing of goroutine. We can loop in the goroutine and wait for the signal on the channel. Once the signal is received, the goroutine will exit. The following is a sample code:

package main

import (
    "fmt"
    "time"
)

func main() {
    quit := make(chan bool)

    go func() {
        for {
            select {
            case <-quit:
                fmt.Println("goroutine stopped")
                return
            default:
                fmt.Println("working...")
            }
            time.Sleep(1 * time.Second)
        }
    }()

    time.Sleep(5 * time.Second)
    fmt.Println("sending quit signal")
    quit <- true

    time.Sleep(2 * time.Second)
    fmt.Println("exiting program")
}

In the above example, we created a Boolean channel named quit and started a goroutine in the main function. The goroutine loop waits for a signal on the channel, and once the signal is received, the goroutine will exit. In the main function, we wait for 5 seconds and then send a true value to the channel to trigger the shutdown of the goroutine. Finally, we wait 2 seconds for the program to exit.

Use context to cancel goroutine

We can also use context.WithCancel function to cancel goroutine. This function will return a context (Context) and a cancellation function (CancelFunc). Context is a type used to pass contextual information between goroutines. We can combine Context with channels to gracefully shut down goroutines. The following is a sample code:

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    ctx, cancel := context.WithCancel(context.Background())

    go func(ctx context.Context) {
        for {
            select {
            case <-ctx.Done():
                fmt.Println("goroutine stopped")
                return
            default:
                fmt.Println("working...")
            }
            time.Sleep(1 * time.Second)
        }
    }(ctx)

    time.Sleep(5 * time.Second)
    fmt.Println("canceling goroutine")
    cancel()

    time.Sleep(2 * time.Second)
    fmt.Println("exiting program")
}

In the above example, we use the WithCancel function in the context package to create a context and use this context to start a goroutine. The goroutine loop waits for the return value of the context's Done() function to check whether it needs to exit. An additional benefit of using context compared to channels is that it can be used to pass context information (such as request ID, timeout, etc.).

Avoid goroutine leakage

In Golang, goroutine leakage is a common problem. This happens when a goroutine is canceled or shut down before completing its tasks, or it runs out of threads or memory without shutting down properly.

In order to avoid goroutine leaks, we need to consider its life cycle before creating a goroutine. We need to ensure that the goroutine can be released correctly so that the memory can be reclaimed in a timely manner. We should use channels or contexts for goroutine control and coordination whenever possible. When a goroutine is no longer needed, we should use a channel or context to send a signal to let it exit automatically.

Summary

In this article, we briefly introduced how to gracefully shut down goroutines in Golang. We've explored two approaches: using channels and using contexts. At the same time, we also discussed how to avoid the common problem of goroutine leaks. This is a very important topic for every Golang developer because correctly controlling the life cycle of goroutines is very critical when writing high-concurrency applications.

The above is the detailed content of How golang performs the shutdown operation of goroutine. For more information, please follow other related articles on the PHP Chinese website!