编辑“︁Goroutine”︁

{{NoteTA
|G1=IT
}}

'''Goroutine'''是[[Go]]语言中实现并发编程的轻量级线程，由Go运行时管理。与操作系统线程相比，goroutine的创建和切换开销极小，使得开发者可以轻松创建成千上万的并发任务。

== 概述 ==
Goroutine具有以下核心特性：
* '''轻量级''' - 初始栈大小仅2KB（可动态扩容）
* '''低成本''' - 创建和调度由Go运行时管理，不直接依赖OS线程
* '''通信机制''' - 通过[[channel]]实现安全的goroutine间通信
* '''调度模型''' - 采用M:N调度模型（M个goroutine映射到N个OS线程）

== 基本用法 ==
使用<code>go</code>关键字即可启动goroutine：

<syntaxhighlight lang="go">
package main

import (
    "fmt"
    "time"
)

func say(s string) {
    for i := 0; i < 3; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

func main() {
    go say("world")  // 启动goroutine
    say("hello")     // 主goroutine
}
</syntaxhighlight>

输出示例：
<pre>
hello
world
hello
world
hello
world
</pre>

== 调度原理 ==
Go运行时使用'''GMP调度模型'''：
<mermaid>
graph TD
    G[Goroutine队列] --> P[逻辑处理器P]
    P --> M[OS线程M]
    M --> CPU核心
</mermaid>

* '''G''' (Goroutine)：待执行的任务
* '''M''' (Machine)：操作系统线程
* '''P''' (Processor)：调度上下文，包含本地运行队列

== 同步机制 ==
=== Channel通信 ===
[[channel]]是goroutine间通信的主要方式：

<syntaxhighlight lang="go">
func worker(done chan bool) {
    fmt.Print("working...")
    time.Sleep(time.Second)
    done <- true  // 发送完成信号
}

func main() {
    done := make(chan bool)
    go worker(done)
    <-done  // 阻塞等待结果
}
</syntaxhighlight>

=== WaitGroup同步 ===
<code>sync.WaitGroup</code>用于等待一组goroutine完成：

<syntaxhighlight lang="go">
var wg sync.WaitGroup

func worker(id int) {
    defer wg.Done()
    fmt.Printf("Worker %d starting\n", id)
    time.Sleep(time.Second)
}

func main() {
    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go worker(i)
    }
    wg.Wait()  // 等待所有worker完成
}
</syntaxhighlight>

== 最佳实践 ==
1. 避免goroutine泄漏（确保所有goroutine都能退出）
2. 使用带缓冲的channel处理生产-消费模式
3. 限制并发数量（如使用semaphore模式）
4. 优先使用<code>context</code>处理取消和超时

== 性能特点 ==
对比传统线程：
{| class="wikitable"
! 特性 !! Goroutine !! OS线程
|-
| 创建开销 || ~2-4µs || ~1ms
|-
| 内存占用 || 初始2KB || 默认1-8MB
|-
| 切换成本 || ~200ns || ~1µs
|}

== 实际应用 ==
=== Web服务器 ===
处理HTTP请求的典型模式：
<syntaxhighlight lang="go">
func handleRequest(w http.ResponseWriter, r *http.Request) {
    go processRequest(r)  // 异步处理
    w.Write([]byte("请求已接收"))
}
</syntaxhighlight>

=== 并行计算 ===
使用worker池处理任务：
<syntaxhighlight lang="go">
func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        results <- j * 2  // 处理任务
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    // 启动3个worker
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    // 发送任务
    for j := 1; j <= 9; j++ {
        jobs <- j
    }
    close(jobs)

    // 收集结果
    for a := 1; a <= 9; a++ {
        <-results
    }
}
</syntaxhighlight>

== 参见 ==
* [[channel (Go)]]
* [[Go语言]]
* [[并发编程]]

[[Category:Go语言]]
[[Category:并发编程]]
[[Category:计算机科学]]