How to stop goroutine in Golang

In Golang, goroutine is the basic unit of concurrent programming. It is a very powerful and commonly used asynchronous programming technology in Golang. However, during actual development, we may need to stop an executing goroutine. This article will discuss how to stop goroutine in Golang.

Why you need to stop goroutine

In concurrent programming, we usually use goroutine to handle tasks. These tasks are usually independent and do not interfere with each other, and are not related to each other. Sometimes we need to stop certain goroutines while the program is running in order to free up resources, avoid wasting CPU resources, or for other reasons. This is the case of stopping the goroutine instead of waiting for the goroutine to finish.

In Golang, goroutine is a lightweight thread, and they are managed by the scheduler. The scheduler is responsible for allocating goroutines to available CPU cores for execution. In Golang, the common technique for stopping goroutine is implemented through channel. Next we will discuss in detail how to use channel to stop goroutine.

Use channel to stop goroutine

In Golang, each goroutine has a unique identifier and can interact with the scheduler through the identifier. You can use a channel to send a message to a goroutine to notify it to stop execution. Normally, we use a bool type channel as the stop channel to control the execution flow of goroutine.

To demonstrate how to stop goroutine, below we use an example to illustrate how to stop goroutine in Golang. Please look at the following code:

package main

import (
    "fmt"
    "time"
)

func worker(stopCh <-chan bool) {
    fmt.Println("Worker started.")
    for {
        select {
        case <-stopCh:
            fmt.Println("Worker stopped.")
            return
        default:
            fmt.Println("Working...")
            time.Sleep(1 * time.Second)
        }
    }
}

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

    go worker(stopCh)

    time.Sleep(5 * time.Second)
    stopCh <- true

    time.Sleep(1 * time.Second)
    fmt.Println("Main stopped.")
}

In the above code, we define a worker function to perform tasks, and also define a stopCh channel to stop the execution of the worker function. In the main function, we start a goroutine to execute the worker function, and send a stop signal to the stopCh channel after 5 seconds to stop the execution of the worker function.

In the worker function, we use the select statement to listen to the stopCh channel. Once the stop signal is received, we exit the loop and stop execution. In the default case branch, the worker function will continuously execute "Working..." and fall into sleep state. This loop will continue until the stopCh channel receives a signal.

Summary

In Golang, stopping goroutine is achieved by using channel. We can use a bool type channel to notify goroutine to stop execution, and use the select statement in goroutine to listen for the stop signal. When a stop signal is received, the goroutine exits the loop and stops execution. Through this method, we can well control the execution process of goroutine and avoid the waste of resources.

The above is how to implement goroutine stopping in Golang. In actual development, we usually need to coordinate the execution processes of multiple goroutines and ensure that they stop execution at the right time. Therefore, it is very important to understand and master the stopping method of goroutine.

The above is the detailed content of How to stop goroutine in Golang. For more information, please follow other related articles on the PHP Chinese website!