Go 语言协程的案例

Go 语言的协程（goroutine）是轻量级的线程，非常适合用于并发处理。以下是一些使用 Go 语言协程的案例：

### 案例 1：并发下载文件
假设你需要并发下载多个文件，可以使用协程来实现。

```go

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "sync"
)

func downloadFile(url string, wg *sync.WaitGroup) {
    defer wg.Done()
    resp, err := http.Get(url)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.Body.Close()

    // 模拟文件保存操作
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Printf("Downloaded %s\n", url)
}

func main() {
    var wg sync.WaitGroup

    urls := []string{
        "http://example.com/file1",
        "http://example.com/file2",
        "http://example.com/file3",
    }

    for _, url := range urls {
        wg.Add(1)
        go downloadFile(url, &wg)
    }

    wg.Wait()
    fmt.Println("All files downloaded.")
}

```

### 案例 2：并发处理数据
假设你有一个数据列表，需要并发处理每个数据项。

```go

package main

import (
    "fmt"
    "sync"
)

func processItem(item int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Processing item %d\n", item)
}

func main() {
    var wg sync.WaitGroup

    items := []int{1, 2, 3, 4, 5}

    for _, item := range items {
        wg.Add(1)
        go processItem(item, &wg)
    }

    wg.Wait()
    fmt.Println("All items processed.")
}

```

### 案例 3：并发访问数据库
假设你需要并发访问数据库，处理多个记录。

```go

package main

import (
    "database/sql"
    "fmt"
    "log"
    "sync"

    _ "github.com/go-sql-driver/mysql"
)

func queryDatabase(db *sql.DB, id int, wg *sync.WaitGroup) {
    defer wg.Done()
    row := db.QueryRow("SELECT name FROM users WHERE id = ?", id)
    var name string
    err := row.Scan(&name)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("User %d: %s\n", id, name)
}

func main() {
    var wg sync.WaitGroup

    // 假设连接字符串
    dsn := "username:password@/dbname"
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    userIDs := []int{1, 2, 3, 4, 5}

    for _, id := range userIDs {
        wg.Add(1)
        go queryDatabase(db, id, &wg)
    }

    wg.Wait()
    fmt.Println("All database queries completed.")
}

```

### 案例 4：并发读取多个通道
假设你有多条通道，需要并发读取它们的内容。

```go

package main

import (
    "fmt"
    "sync"
)

func readChannel(ch chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    for v := range ch {
        fmt.Printf("Received %d from channel\n", v)
    }
}

func main() {
    var wg sync.WaitGroup

    ch1 := make(chan int)
    ch2 := make(chan int)

    go func() {
        for i := 0; i < 5; i++ {
            ch1 <- i
        }
        close(ch1)
    }()

    go func() {
        for i := 5; i < 10; i++ {
            ch2 <- i
        }
        close(ch2)
    }()

    wg.Add(2)
    go readChannel(ch1, &wg)
    go readChannel(ch2, &wg)

    wg.Wait()
    fmt.Println("All channels read.")
}

```

这些案例展示了如何使用 Go 语言的协程来实现并发处理，提高程序的执行效率。