go 中的协程是一種輕量級執行緒，可透過 goroutine 並發執行程式碼，提供以下優勢：輕量級且易於管理高並發的天然支援可避免鎖的死鎖和性能損耗go 透過以下模型實作協程運算：通道（channel）：用於協程間通訊，避免數據競爭。共享記憶體：使用原子操作確保數據一致性。鎖：傳統協程原語，保護共享數據訪問。

Go 协程与并发模型详解

协程基础

协程是轻量级的线程，与 goroutine 概念类似，由 Go 语言的运行时调度器管理。它允许在单个进程中并发执行代码，提高应用程序性能。

立即学习“go语言免费学习笔记（深入）”；

协程的优势

• 轻量级且易于管理
• 高并发的天然支持
• 可避免锁带来的死锁和性能损耗

创建协程

使用 go 关键字创建协程：

func main() {
    go func() {
        fmt.Println("Hello from a goroutine")
    }()
}

并发模型

Go 语言提供了以下几种并发模型：

• 基于通道（channel）: 用于协程之间通信，避免共享内存导致的数据竞争。
• 共享内存: 使用原子操作（sync/atomic 包）操作共享变量，确保数据一致性。
• 锁: 传统的并发原语，用于保护共享数据访问。

实战案例

使用通道进行并发计算:

func main() {
    ch := make(chan int)
    for i := 0; i < 10; i++ {
        go func(i int) {
            ch <- i * i
        }(i)
    }

    for i := 0; i < 10; i++ {
        fmt.Println(<-ch)
    }
}

使用 goroutine 池进行并发任务:

package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

func main() {
    const numTasks = 100

    // 创建 goroutine 池
    pool := make(chan func(), numTasks)

    for i := 0; i < numTasks; i++ {
        go func(i int) {
            // 从池中获取任务
            task := <-pool

            // 执行任务
            time.Sleep(time.Second)
            fmt.Printf("Task %d completedn", i)

            // 将任务放回池中
            pool <- task
        }(i)
    }

    // 创建任务并将其放入池中
    ctx := context.Background()
    for i := 0; i < numTasks; i++ {
        pool <- func() {
            fmt.Printf("Task %d startedn", i)
        }
    }

    // 等待任务完成
    for i := 0; i < numTasks; i++ {
        go func(i int) {
            <-pool
            fmt.Printf("Task %d completedn", i)
        }(i)
    }

    // 等待所有任务完成
    time.Sleep(5 * time.Second)
}

使用 Mutex 进行并发共享内存:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var count int
    var mu sync.Mutex

    for i := 0; i < 1000; i++ {
        go func(i int) {
            mu.Lock()
            count++
            time.Sleep(time.Millisecond)
            mu.Unlock()
        }(i)
    }

    time.Sleep(time.Second)
    fmt.Println(count) // 打印 1000
}