Go语言并发：释放程序潜能的魔力

原创 Go先锋 Go先锋 2023-11-06 08:02 发表于广东

收录于合集#Go语言并发1个

Go 先锋

读完需要

9分钟

速读仅需 3 分钟

概述

在编程领域，处理多任务和并发操作是必不可少的。

Go 语言以其简洁而强大的并发机制而闻名。本文将简单探讨 Go 语言中的并发。

从基本概念到并发的优势，详细解释并发的原理，并通过通俗易懂的示例代码领略 Go 语言并发编程的魅力。

主要内容包括

并发与并行的区别

Goroutine：Go 语言轻量级线程的魅力

Channel：实现 Goroutine 间的通信

Select 语句：处理多 Channel 的选择

并发的优势

并发中的常见问题与解决方案

并发的最佳实践

1. 并发与并行的区别

在开始之前，需要明确“并发”和“并行”的区别。并发是指一个程序拥有多个独立的执行路径，而并行则是指这些执行路径同时执行。

Go 语言通过 goroutine 和 channel 实现了并发，让程序可以高效地同时执行多个任务。

2. Goroutine：Go 语言轻量级线程的魅力

2.1 Goroutine 的创建与启动

package main
import (  "fmt"  "time")
func main() {  for i := 1; i <= 3; i++ {    go printNumber(i)  }
  // 等待goroutine执行完成  time.Sleep(time.Second)}
func printNumber(num int) {  fmt.Println("Number:", num)}

在上面例子中，创建了三个 goroutine，它们会并发执行 printNumber 函数。

通过 go 关键字，启动了新的 goroutine，实现了并发执行的效果。

2.2 Goroutine 的同步与等待

package main
import (  "fmt"  "sync"  "time")
func main() {  var wg sync.WaitGroup
  for i := 1; i <= 3; i++ {    wg.Add(1)    go printNumber(i, &wg)  }
  // 等待所有goroutine执行完成  wg.Wait()}
func printNumber(num int, wg *sync.WaitGroup) {
  // 减少WaitGroup的计数  defer wg.Done() 
  time.Sleep(time.Second)  fmt.Println("Number:", num)}

在上面例子中，使用 sync.WaitGroup 来等待所有的 goroutine 执行完成。

每个 goroutine 执行完成后，调用 Done() 方法来减少 WaitGroup 的计数，最终实现了等待所有 goroutine 的效果。

3. Channel：实现 Goroutine 间的通信

3.1 无缓冲 Channel

package main
import (  "fmt")
func main() {  ch := make(chan int)
  go sendData(ch)  go receiveData(ch)
  // 等待一段时间，确保goroutine有足够时间执行  fmt.Scanln()}
func sendData(ch chan int) {  ch <- 1  ch <- 2  ch <- 3  close(ch)}
func receiveData(ch chan int) {  for {    num, ok := <-ch    if !ok {      fmt.Println("Channel已关闭")      return    }    fmt.Println("Received:", num)  }}

在上面示例中，创建了一个无缓冲的 channel，通过它实现了 goroutine 之间的同步通信。

sendData 函数向 channel 发送数据，receiveData 函数从 channel 接收数据，通过 close(ch) 关闭 channel，通知接收方数据发送完成。

3.2 有缓冲 Channel

package main
import (  "fmt")
func main() {  // 创建有缓冲的channel，缓冲大小为2  ch := make(chan int, 2) 
  go sendData(ch)
  // 等待一段时间，确保goroutine有足够时间执行  fmt.Scanln()}
func sendData(ch chan int) {  ch <- 1  fmt.Println("Sent: 1")  ch <- 2  fmt.Println("Sent: 2")  ch <- 3 // 此行代码会引发panic，因为channel已满}

上面例子中，创建了一个缓冲大小为 2 的 channel，通过它实现了 goroutine 之间的异步通信。

sendData 函数向 channel 发送数据，由于 channel 的缓冲大小为 2，可以发送两个数据。

当尝试发送第三个数据时，由于 channel 已满，会引发异常。

4. Select 语句：处理多 Channel 的选择

package main
import (  "fmt"  "time")
func main() {  ch1 := make(chan string)  ch2 := make(chan string)
  go func() {    time.Sleep(2 * time.Second)    ch1 <- "Data from Channel 1"  }()
  go func() {    time.Sleep(1 * time.Second)    ch2 <- "Data from Channel 2"  }()
  // 使用select语句
  select {  case data1 := <-ch1:    fmt.Println(data1)  case data2 := <-ch2:    fmt.Println(data2)  case <-time.After(3 * time.Second):    fmt.Println("Timeout: No data received in 3 seconds.")  }}

在这个例子中，创建了两个 goroutine 分别向 ch1 和 ch2 发送数据。

通过 select 语句，可以等待多个 channel 的数据，并选择第一个准备好的 channel 进行处理。

time.After(3 * time.Second) 表示等待 3 秒，如果在这个时间内没有任何 channel 的数据准备好，就会执行 Timeout 分支。

5. 并发的优势

5.1 提高程序性能

并发允许程序同时处理多个任务，而不是依次执行。这样可以充分利用 CPU 资源，提高程序的运行效率。

在多核心处理器上，并发更是能够实现真正的并行执行，极大地提高了程序的性能。

5.2 简化代码逻辑

使用 goroutine 和 channel，可以避免复杂的回调和锁机制，使得程序的逻辑更加清晰和简单。

并发模型让代码更容易理解和维护，减少了许多传统多线程编程中可能遇到的问题。

5.3 高效利用多核心处理器

在传统的多线程编程中，由于线程的创建和销毁需要时间，而且线程间的切换也会带来性能开销。

而 goroutine 是由 Go 语言的运行时管理的轻量级线程，创建和销毁的开销非常小。

可以轻松创建成千上万个 goroutine，高效利用多核心处理器。

6. 并发中的常见问题与解决方案

6.1 数据竞争：保护共享资源

在多个 goroutine 中同时访问和修改共享资源可能引发数据竞争问题。

为了避免数据竞争，可以使用sync包中的Mutex来保护共享资源的访问。

package main
import (  "fmt"  "sync")
var counter intvar mutex sync.Mutex
func main() {  var wg sync.WaitGroup  for i := 0; i < 5; i++ {    wg.Add(1)    go increment(&wg)  }  wg.Wait()  fmt.Println("Counter:", counter)}
func increment(wg *sync.WaitGroup) {  defer wg.Done()  mutex.Lock()  counter++  mutex.Unlock()}