How to stop thread in Golang

In Golang, we can create concurrent threads through goroutine, and the life cycle of these threads is generally managed by Golang's runtime system. However, in some cases, we may need to control the life cycle of a thread, such as stopping a running thread after a certain condition is met. This article will introduce how to stop threads in Golang.

1. Using channels

In Golang, channels are a very powerful tool that can be used for communication and synchronization between threads. And channels in Golang are thread-safe, so we can use channels to stop threads.

First, we define a stop channel:

stopCh := make(chan struct{})

Then, in our thread, we can send a signal to the channel when a certain condition is met, indicating that the current thread needs to be stopped. :

select {
case <- stopCh:
    // 收到停止信号，退出线程
    return
default:
    // 正常运行代码
}

Finally, we only need to send a signal to this channel where the thread needs to be stopped to stop the thread:

close(stopCh)

2. Use context

In versions after Golang 1.7, the context package is added to the standard library, which provides a more flexible method to control the life cycle of threads.

We first create a context:

ctx, cancel := context.WithCancel(context.Background())

Then, in our thread, we can listen to this context and exit the thread if a stop signal is received:

for {
    select {
    case <- ctx.Done():
        // 收到停止信号，退出线程
        return
    default:
        // 正常运行代码
    }
}

Finally, we only need to call the cancel function where the thread needs to be stopped to stop the thread:

cancel()

3. Use the sync package

In addition to using channels and context, Golang The sync package in the standard library also provides a way to control the life cycle of threads. We can use the WaitGroup in the sync package to coordinate the running of threads.

First, we create a WaitGroup:

var wg sync.WaitGroup

Then, in our thread, we start a coroutine and execute the code, and control its life cycle through the WaitGroup counter:

wg.Add(1)
go func() {
    for {
        select {
        case <- stopCh:
            // 停止信号，清除WaitGroup计数器
            wg.Done()
            return
        default:
            // 正常运行代码
        }
    }
}()

Finally, we only need to wait for all coroutines to exit where we need to stop the thread:

close(stopCh)
wg.Wait()

Summary:

The above are the three ways to stop threads in Golang . In different scenarios, we can choose different ways to stop threads as needed. The channel method is simple and easy to use, the context method is more flexible, and the sync.WaitGroup method can control the life cycle of multiple coroutines. In actual use, we need to make a choice based on specific application scenarios.

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