WEBKT

用 Go 语言玩转并发编程：Goroutine 和 Channel 的深度实践与避坑指南

23 0 0 0

并发编程，听起来就让人头大？别慌，今天咱们就用 Go 语言，把这事儿给它整明白！

为啥要学并发？

想象一下，你写了个程序，用户点一下按钮，程序就卡住不动了，得等半天才能响应。这用户体验，简直是灾难！并发编程，就是为了解决这个问题。它能让你的程序同时处理多个任务，提高效率，改善用户体验。尤其是在高并发的互联网应用中，并发编程简直是必备技能。

Go 语言：天生为并发而生

Go 语言在并发方面，那是相当的牛！它内置了 goroutine 和 channel 这两个神器，让并发编程变得简单又高效。相比于传统的线程，goroutine 更加轻量级，创建和销毁的开销很小。而 channel 则提供了一种安全、高效的goroutine间通信方式，避免了共享内存带来的各种问题。

Goroutine：轻量级“线程”

你可以把 goroutine 理解成一种轻量级的线程。创建 goroutine 非常简单，只需要在函数调用前加上 go 关键字即可。例如：

package main
 
import (
    "fmt"
    "time"
)
 
func say(s string) {
    for i := 0; i < 5; i++ {
        fmt.Println(s)
        time.Sleep(100 * time.Millisecond)
    }
}
 
func main() {
    go say("world")
    say("hello")
}

在这个例子中，go say("world") 启动了一个新的 goroutine 来执行 say 函数。主 goroutine (也就是 main 函数所在的 goroutine) 继续执行 say("hello")。你会发现，"hello" 和 "world" 会交替打印出来，这就是并发执行的效果。

Channel：Goroutine 间的通信桥梁

仅仅让 goroutine 跑起来还不够，它们之间需要通信，交换数据。Channel 就是用来解决这个问题的。你可以把 channel 想象成一个管道，goroutine 可以通过它来发送和接收数据。

package main
 
import (
    "fmt"
)
 
func sum(s []int, c chan int) {
    sum := 0
    for _, v := range s {
        sum += v
    }
    c <- sum // 将 sum 发送到 channel c
}
 
func main() {
    s := []int{7, 2, 8, -9, 4, 0}
 
    c := make(chan int)
    go sum(s[:len(s)/2], c)
    go sum(s[len(s)/2:], c)
    x, y := <-c, <-c // 从 channel c 接收
 
    fmt.Println(x, y, x+y)
}

在这个例子中，我们创建了一个 channel c，然后启动了两个 goroutine 来计算数组 s 的两部分之和。每个 goroutine 将计算结果发送到 channel c。主 goroutine 从 channel c 接收两个结果，并打印出来。

Channel 的类型

Channel 有两种类型：

  • 带缓冲的 Channel： c := make(chan int, 10) 创建了一个可以存储 10 个 int 值的带缓冲 channel。只有当 channel 满了，发送操作才会阻塞。只有当 channel 空了，接收操作才会阻塞。
  • 不带缓冲的 Channel： c := make(chan int) 创建了一个不带缓冲的 channel。发送和接收操作必须同时准备好，才能进行。也就是说，发送方必须等到接收方准备好接收数据，反之亦然。这种 channel 也被称为同步 channel。

实战案例：并发下载文件

假设我们要下载多个文件，如果一个一个下载，速度会很慢。我们可以使用 goroutine 和 channel 来并发下载，提高效率。

package main
 
import (
    "fmt"
    "io"
    "net/http"
    "os"
    "sync"
)
 
func downloadFile(url string, filename string, wg *sync.WaitGroup, ch chan string) {
    defer wg.Done()
    fmt.Println("Downloading", url, "to", filename)
 
    resp, err := http.Get(url)
    if err != nil {
        ch <- fmt.Sprintf("Error downloading %s: %s", url, err)
        return
    }
    defer resp.Body.Close()
 
    out, err := os.Create(filename)
    if err != nil {
        ch <- fmt.Sprintf("Error creating file %s: %s", filename, err)
        return
    }
    defer out.Close()
 
    _, err = io.Copy(out, resp.Body)
    if err != nil {
        ch <- fmt.Sprintf("Error writing file %s: %s", filename, err)
        return
    }
 
    ch <- fmt.Sprintf("Downloaded %s to %s", url, filename)
}
 
func main() {
    urls := []string{
        "https://www.baidu.com",
        "https://www.google.com",
        "https://www.bing.com",
    }
 
    var wg sync.WaitGroup
    ch := make(chan string, len(urls))
 
    for i, url := range urls {
        wg.Add(1)
        filename := fmt.Sprintf("file%d.html", i)
        go downloadFile(url, filename, &wg, ch)
    }
 
    wg.Wait()
    close(ch)
 
    for msg := range ch {
        fmt.Println(msg)
    }
}

在这个例子中，我们使用 sync.WaitGroup 来等待所有 goroutine 完成。downloadFile 函数负责下载单个文件，并将下载结果发送到 channel ch。主 goroutine 启动多个 goroutine 来并发下载文件，然后从 channel ch 接收下载结果。

并发编程的常见问题与避坑指南

并发编程虽然强大，但也容易出错。下面是一些常见的并发问题以及解决方法：

  • 竞态条件（Race Condition）： 当多个 goroutine 同时访问和修改共享资源时，就可能发生竞态条件。例如，多个 goroutine 同时修改同一个变量的值，最终结果可能是不确定的。

    • 解决方法： 使用互斥锁（sync.Mutex）来保护共享资源。只有获取到锁的 goroutine 才能访问共享资源。

      		package main
      		 
      		import (
      		    "fmt"
      		    "sync"
      		    "time"
      		)
      		 
      		var counter int
      		var lock sync.Mutex
      		 
      		func increment() {
      		    lock.Lock()
      		    defer lock.Unlock()
      		    counter++
      		    fmt.Println("Incrementing:", counter)
      		    time.Sleep(time.Millisecond)
      		}
      		 
      		func main() {
      		    var wg sync.WaitGroup
      		 
      		    for i := 0; i < 100; i++ {
      		        wg.Add(1)
      		        go func() {
      		            defer wg.Done()
      		            increment()
      		        }()
      		    }
      		 
      		    wg.Wait()
      		    fmt.Println("Final Counter:", counter)
      		}

  • 死锁（Deadlock）： 当多个 goroutine 互相等待对方释放资源时，就可能发生死锁。例如，goroutine A 等待 goroutine B 释放资源，而 goroutine B 又在等待 goroutine A 释放资源，就形成了死锁。

    • 解决方法： 避免循环等待。尽量按照固定的顺序获取锁，避免多个 goroutine 互相等待。

  • 饥饿（Starvation）： 当一个 goroutine 长期无法获取到所需的资源时，就可能发生饥饿。例如，一个 goroutine 的优先级很低，总是被其他 goroutine 抢占资源，就可能发生饥饿。

    • 解决方法： 可以使用 runtime.Gosched() 让当前 goroutine 放弃 CPU 资源，让其他 goroutine 有机会运行。但是，这并不能完全解决饥饿问题，需要根据具体情况进行调整。

  • 内存竞争（Memory Contention）： 多个 goroutine 同时访问和修改同一块内存时，会发生内存竞争，导致性能下降。现代 CPU 为了解决这个问题，引入了缓存一致性协议，但仍然会带来一定的开销。

    • 解决方法： 尽量避免多个 goroutine 共享同一块内存。可以使用 channel 来传递数据，或者使用 sync.Pool 来复用对象。

  • 过度并发（Over-concurrency）： 启动过多的 goroutine 并不一定能提高性能，反而可能导致性能下降。因为 goroutine 的调度也需要开销，过多的 goroutine 会导致 CPU 在不同的 goroutine 之间频繁切换，浪费时间。

    • 解决方法： 根据 CPU 的核心数和任务的特点，合理设置 goroutine 的数量。可以使用 runtime.NumCPU() 获取 CPU 的核心数，然后根据实际情况进行调整。可以使用 worker pool 来限制并发数量。

一些最佳实践

  • 使用 channel 进行通信： 尽量使用 channel 来进行 goroutine 间的通信，避免使用共享内存。Channel 提供了一种安全、高效的通信方式，可以避免竞态条件和死锁等问题。
  • 使用互斥锁保护共享资源： 如果必须使用共享内存，一定要使用互斥锁来保护共享资源。确保只有一个 goroutine 能够访问共享资源。
  • 避免死锁： 避免循环等待。尽量按照固定的顺序获取锁，避免多个 goroutine 互相等待。
  • 合理设置 goroutine 的数量： 根据 CPU 的核心数和任务的特点，合理设置 goroutine 的数量。避免过度并发。
  • 使用 context 管理 goroutine 的生命周期： 可以使用 context 来控制 goroutine 的生命周期。当 context 被取消时，所有与该 context 关联的 goroutine 都会收到取消信号，可以优雅地退出。

总结

Go 语言的并发编程非常强大，但同时也需要注意一些问题。掌握 goroutine 和 channel 的使用方法，了解常见的并发问题以及解决方法，才能写出高效、稳定的并发程序。

希望这篇文章能帮助你更好地理解 Go 语言的并发编程。赶紧动手实践一下吧！你会发现，并发编程并没有想象中那么难！加油！

并发老司机 Go语言并发编程Goroutine

评论点评

打赏赞助
sponsor

感谢您的支持让我们更好的前行

分享

QRcode

https://www.webkt.com/article/9996