Home > Article > Backend Development > Golang Concurrent Programming Practical Life Cycle Management of Goroutines
Golang Concurrent Programming Practical Life Cycle Management of Goroutines
In Golang, Goroutines (coroutines) are the key concept to achieve concurrency. Goroutines allow developers to perform multiple tasks at the same time in a concise and efficient way, but at the same time, the life cycle of Goroutines needs to be managed reasonably to avoid resource leaks and instability.
This article will introduce how to manage the life cycle of Goroutines in Golang, including creating, controlling, waiting for and ending coroutines. At the same time, we provide code examples to help readers better understand and apply these concepts.
package main import "fmt" func main() { go printMessage("Hello, Goroutines!") fmt.Println("This is the main function.") } func printMessage(message string) { fmt.Println(message) }
In the above example, we use the keyword "go" to create a coroutine to concurrently execute the printMessage function , while the main function main continues to execute. This way, "This is the main function." will be printed first, and then "Hello, Goroutines!" will be printed.
The following example shows how to use channel to control the execution order of two coroutines:
package main import ( "fmt" "time" ) func main() { done := make(chan bool) go printMessage("Hello", done) go printMessage("Goroutines", done) <-done <-done } func printMessage(message string, done chan bool) { fmt.Println(message) time.Sleep(time.Second) done <- true }
In the above example, we created a done channel to synchronize the execution of the coroutines . At the end of each coroutine, we will send a boolean value true in the done channel. In the main function, by receiving the boolean value of the done channel, we can ensure that the two coroutines execute in order.
The following example shows how to use WaitGroup to wait for all coroutines to finish executing:
package main import ( "fmt" "sync" ) func main() { var wg sync.WaitGroup wg.Add(2) go printMessage("Hello", &wg) go printMessage("Goroutines", &wg) wg.Wait() } func printMessage(message string, wg *sync.WaitGroup) { defer wg.Done() fmt.Println(message) }
In the above example, we first create a WaitGroup variable wg and use its Add method Set the number of coroutines to wait for to 2. Then, in each coroutine function, use the defer statement to call the WaitGroup's Done method to indicate that the coroutine has completed execution. Finally, call the Wait method to wait for all coroutines to complete execution.
The following example shows how to use the context package to terminate a coroutine:
package main import ( "context" "fmt" "time" ) func main() { ctx, cancel := context.WithCancel(context.Background()) go printMessage(ctx, "Hello") time.Sleep(time.Second * 2) cancel() time.Sleep(time.Second) fmt.Println("Main goroutine ended.") } func printMessage(ctx context.Context, message string) { for { select { case <-ctx.Done(): return default: fmt.Println(message) time.Sleep(time.Second) } } }
In the above example, we created a context ctx and a cancel using the WithCancel function of the context package function. In the printMessage coroutine, use the select statement to listen to the ctx.Done() channel. Once the closing signal is received, the coroutine will terminate.
By calling the cancel function, a shutdown signal can be sent to ctx to terminate the executing coroutine.
Summary:
In this article, we introduced how to manage the life cycle of Goroutines in Golang, including creating, controlling, waiting for and ending coroutines. By properly managing Goroutines, we can avoid resource leaks and instability and improve program reliability and performance.
Through actual code examples, I believe readers can better understand and apply these concepts. In actual development, reasonable management of the life cycle of Goroutines will help improve the writing quality and performance of concurrent programs.
The above is the detailed content of Golang Concurrent Programming Practical Life Cycle Management of Goroutines. For more information, please follow other related articles on the PHP Chinese website!