启动goroutine只需在函数前加go关键字，它轻量且由Go运行时调度，通过WaitGroup、Channel和Context可实现同步、通信与生命周期管理，避免泄露与竞争。
启动一个goroutine就像给你的程序打了一针肾上腺素，让它瞬间拥有了并发执行的能力。它不是创建一个新的线程，而是在现有的线程上“复用”资源，这就是它轻量级的核心所在。
启动goroutine非常简单，只需要在函数调用前加上
go关键字。例如，
go myFunction()就会启动一个新的 goroutine 来执行
myFunction。
启动goroutine之后，主goroutine（也就是
main函数所在的goroutine）会继续执行，不会阻塞等待新启动的goroutine执行完毕。这就是并发的魅力，多个任务可以同时进行，而不是一个接一个地排队。
如何优雅地管理Goroutine？
立即学习“go语言免费学习笔记（深入）”；
Goroutine虽然强大，但如果使用不当，也会带来一些问题，比如资源竞争、死锁等。因此，我们需要一些工具和技巧来管理它们。
使用WaitGroup同步Goroutine
sync.WaitGroup是一个非常有用的工具，它可以用来等待一组goroutine执行完毕。它的工作方式是：
- 在启动goroutine之前，调用
wg.Add(n)
，其中n
是要启动的goroutine的数量。 - 在每个goroutine执行完毕之后，调用
wg.Done()
。 - 在主goroutine中，调用
wg.Wait()
，它会阻塞，直到所有goroutine都调用了wg.Done()
。
package main
import (
"fmt"
"sync"
"time"
)
func worker(id int, wg *sync.WaitGroup) {
defer wg.Done() // 确保goroutine退出时调用Done()
fmt.Printf("Worker %d starting\n", id)
time.Sleep(time.Second) // 模拟耗时操作
fmt.Printf("Worker %d done\n", id)
}
func main() {
var wg sync.WaitGroup
for i := 1; i <= 3; i++ {
wg.Add(1) // 启动一个goroutine，计数器加1
go worker(i, &wg)
}
wg.Wait() // 等待所有goroutine完成
fmt.Println("All workers done!")
}在这个例子中，我们启动了三个worker goroutine，每个goroutine都会打印一条开始和结束的消息，并且休眠一秒钟来模拟耗时操作。
wg.Wait()会阻塞主goroutine，直到所有worker goroutine都执行完毕。
使用Channel进行通信
Goroutine之间的通信，最佳实践是使用Channel。Channel提供了一种安全的方式来传递数据，避免了共享内存带来的竞争问题。
package main
import (
"fmt"
)
func producer(ch chan int) {
for i := 0; i < 5; i++ {
ch <- i // 发送数据到channel
fmt.Println("Produced:", i)
}
close(ch) // 关闭channel，表示不再发送数据
}
func consumer(ch chan int) {
for num := range ch { // 从channel接收数据，直到channel关闭
fmt.Println("Consumed:", num)
}
}
func main() {
ch := make(chan int) // 创建一个channel
go producer(ch)
go consumer(ch)
// 阻塞主goroutine，等待其他goroutine执行完毕
// 这里可以使用 time.Sleep() 或者 sync.WaitGroup，但channel本身就具有同步能力
var input string
fmt.Scanln(&input)
}在这个例子中，
producergoroutine负责生产数据，并将数据发送到channel中。
consumergoroutine负责从channel中接收数据，并进行消费。
close(ch)用于关闭channel，告诉consumer goroutine不再有更多的数据发送过来。
Goroutine泄露了怎么办？
Goroutine泄露是指goroutine启动后，由于某些原因无法正常退出，导致资源占用，最终可能导致程序崩溃。这通常发生在goroutine阻塞在某个操作上，比如等待一个永远不会到来的channel消息，或者死锁。
避免阻塞操作
避免goroutine泄露的关键在于避免阻塞操作。例如，在使用channel时，要确保channel最终会被关闭，或者使用
select语句来处理超时情况。
使用Context控制Goroutine生命周期
context包提供了一种优雅的方式来控制goroutine的生命周期。你可以创建一个
context.Context对象，并将其传递给goroutine。然后，你可以使用
context.WithTimeout或
context.WithCancel来设置超时时间或手动取消goroutine。
package main
import (
"context"
"fmt"
"time"
)
func worker(ctx context.Context, id int) {
fmt.Printf("Worker %d starting\n", id)
select {
case <-time.After(time.Second * 2): // 模拟耗时操作
fmt.Printf("Worker %d done\n", id)
case <-ctx.Done(): // 监听Context的取消信号
fmt.Printf("Worker %d cancelled\n", id)
return
}
}
func main() {
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel() // 确保cancel函数被调用，释放资源
go worker(ctx, 1)
time.Sleep(time.Second * 3) // 模拟主goroutine的耗时操作
fmt.Println("Main function done!")
}在这个例子中，我们使用
context.WithTimeout创建了一个带有超时时间的Context。如果worker goroutine在2秒内没有完成，它会打印一条完成的消息。如果在1秒后，主goroutine执行完毕，它会调用
cancel()函数，取消worker goroutine。worker goroutine会监听Context的取消信号，如果收到信号，它会打印一条取消的消息，并退出。
Goroutine和线程有什么区别？
Goroutine和线程是并发编程中两个重要的概念，但它们之间存在着显著的区别。最核心的区别在于，goroutine是由Go运行时管理的，而线程是由操作系统管理的。这意味着goroutine的创建、销毁和切换的开销远小于线程。
线程的创建和销毁需要操作系统内核的参与，而goroutine的创建和销毁只需要Go运行时的参与，这使得goroutine更加轻量级。此外，goroutine的调度也更加灵活，Go运行时可以根据程序的需要动态地调整goroutine的调度策略。
总结一下，goroutine是Go语言中实现并发的一种轻量级机制，它具有以下优点：
- 轻量级：创建和销毁的开销小
- 高效：调度灵活
- 易用：使用
go
关键字即可启动
通过合理地使用goroutine，我们可以编写出高效、并发的Go程序。
