Golang中如何启动一个goroutine并理解其轻量级特性-Golang-PHP中文网

Golang中如何启动一个goroutine并理解其轻量级特性

P粉602998670

发布： 2025-08-31 11:13:01

原创

305人浏览过

启动goroutine只需在函数前加go关键字，它轻量且由Go运行时调度，通过WaitGroup、Channel和Context可实现同步、通信与生命周期管理，避免泄露与竞争。

golang中如何启动一个goroutine并理解其轻量级特性

启动一个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)
}

登录后复制

在这个例子中，

producer

登录后复制

goroutine负责生产数据，并将数据发送到channel中。

consumer

登录后复制

goroutine负责从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!")
}

登录后复制

在这个例子中，我们使用