Go 語言硬件加速：多核並行化的妙用

概述

隨着計算機硬件架構的演進，多核處理器已經成爲當今主流。

在這個背景下，如何充分利用多核心處理器的性能，提高程序的併發度成爲了一個關鍵問題。

本文將探討在 Go 語言中如何實現多核並行化，充分發揮硬件潛力，提高程序的執行效率。

1. Go 語言併發基礎

在討論多核並行化之前，先回顧一下 Go 語言中的併發基礎知識。

1.1 Goroutine

Goroutine 是 Go 語言中的輕量級線程，由 Go 運行時（runtime）調度。通過關鍵字 go 可以啓動一個新的 Goroutine。

package main
import (
  "fmt"
  "time"
)
func main() {
  go printNumbers()
  printLetters()
}
func printNumbers() {
  for i := 1; i <= 5; i++ {
    fmt.Printf("%d ", i)
    time.Sleep(100 * time.Millisecond)
  }
}
func printLetters() {
  for i := 'a'; i <= 'e'; i++ {
    fmt.Printf("%c ", i)
    time.Sleep(100 * time.Millisecond)
  }
}

在上面示例中，printNumbers 和 printLetters 兩個函數被同時執行，

它們分別打印數字和字母，通過 go 關鍵字實現併發執行。

1.2 Channel

Channel 是 Goroutine 之間進行通信的一種機制。通過 Channel，不同的 Goroutine 可以安全地傳遞數據。

package main
import (
  "fmt"
  "time"
)
func main() {
  ch := make(chan string)
  go sendData(ch)
  receiveData(ch)
}
func sendData(ch chan string) {
  for i := 1; i <= 5; i++ {
    ch <- fmt.Sprintf("Data %d", i)
    time.Sleep(100 * time.Millisecond)
  }
  close(ch)
}
func receiveData(ch chan string) {
  for {
    data, ok := <-ch
    if !ok {
      fmt.Println("Channel closed, exiting...")
      return
    }
    fmt.Println("Received:", data)
  }
}

在上述示例中，sendData 向 Channel 發送數據，receiveData 從 Channel 接收數據。通過 close 關閉 Channel，通知接收方數據已發送完畢。

2. 多核並行化的必要性

隨着硬件技術的發展，多核處理器已經成爲現代計算機的標配。

如果程序無法充分利用多核心處理器，就無法發揮硬件潛力，導致性能瓶頸。

因此，實現多核並行化是提高程序性能的重要手段。

3. Go 語言中的並行化工具

Go 語言內置了一些並行化的工具，例如 sync 包、GOMAXPROCS 等，下面將介紹其中的一些關鍵概念。

3.1 sync 包

sync 包提供了一些基本的同步原語，例如 WaitGroup、Mutex 等，可以用於控制多個 Goroutine 的執行順序和共享資源的訪問。

3.1.1 WaitGroup

WaitGroup 用於等待一組 Goroutine 完成執行。

在啓動每個 Goroutine 前，通過 Add 方法增加計數，Goroutine 執行完成後通過 Done 方法減少計數，通過 Wait 方法阻塞直到計數爲零。

package main
import (
  "fmt"
  "sync"
  "time"
)
func main() {
  var wg sync.WaitGroup
  for i := 0; i < 3; i++ {
    wg.Add(1)
    go func(id int) {
      defer wg.Done()
      fmt.Printf("Goroutine %d started\n", id)
      time.Sleep(2 * time.Second)
      fmt.Printf("Goroutine %d done\n", id)
    }(i)
  }
  wg.Wait()
  fmt.Println("All Goroutines finished")
}

在這個示例中，用 sync.WaitGroup 確保所有 Goroutine 執行完成後再繼續執行主函數。

3.1.2 Mutex

Mutex 用於保護共享資源，防止多個 Goroutine 同時訪問，造成數據競爭。

package main
import (
  "fmt"
  "sync"
  "time"
)
var counter int
var mutex sync.Mutex
func main() {
  var wg sync.WaitGroup
  for i := 0; i < 3; i++ {
    wg.Add(1)
    go func(id int) {
      defer wg.Done()
      incrementCounter(id)
    }(i)
  }
  wg.Wait()
  fmt.Printf("Final Counter: %d\n", counter)
}
func incrementCounter(id int) {
  for i := 0; i < 5; i++ {
    mutex.Lock()
    counter++
    fmt.Printf("Goroutine %d: Counter = %d\n", id, counter)
    mutex.Unlock()
    time.Sleep(100 * time.Millisecond)
  }
}

在這個示例中，使用 sync.Mutex 對 counter 變量進行了保護，確保每次只有一個 Goroutine 能夠修改它。

3.2 GOMAXPROCS

GOMAXPROCS 是一個環境變量，用於設置程序併發執行時的最大 CPU 核心數。

package main
import (
  "fmt"
  "runtime"
  "sync"
  "time"
)
func main() {
  // 設置最大CPU核心數爲2
  runtime.GOMAXPROCS(2) 
  var wg sync.WaitGroup
  for i := 0; i < 3; i++ {
    wg.Add(1)
    go func(id int) {
      defer wg.Done()
      fmt.Printf("Goroutine %d started\n", id)
      time.Sleep(2 * time.Second)
      fmt.Printf("Goroutine %d done\n", id)
    }(i)
  }
  wg.Wait()
  fmt.Println("All Goroutines finished")
}

在這個示例中，用 runtime.GOMAXPROCS 設置最大 CPU 核心數爲 2，以限制程序並行度。

4. 實現多核並行化的實例

用一個實際的例子，演示如何在 Go 語言中實現多核並行化。

4.1 計算併發

假設有一個需要耗時計算的函數 calculate，通過併發執行來提高計算速度。

package main
import (
  "fmt"
  "sync"
  "time"
)
func main() {
  data := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
  result := make([]int, len(data))
  var wg sync.WaitGroup
  for i, d := range data {
    wg.Add(1)
    go func(i, d int) {
      defer wg.Done()
      result[i] = calculate(d)
    }(i, d)
  }
  wg.Wait()
  fmt.Println("Result:", result)
}
func calculate(num int) int {
  time.Sleep(2 * time.Second)
  return num * num
}

在上面示例中，創建了一個包含 10 個元素的切片 data，然後通過併發執行 calculate 函數對每個元素進行計算，最終將結果保存在切片 result 中。

4.2 並行度控制

爲了更好地控制並行度，可使用 GOMAXPROCS 來設置最大 CPU 核心數，並結合 sync 包中的 WaitGroup。

package main
import (
  "fmt"
  "runtime"
  "sync"
  "time"
)
func main() {
  // 設置最大CPU核心數爲2
  runtime.GOMAXPROCS(2) 
  data := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
  result := make([]int, len(data))
  var wg sync.WaitGroup
  var mu sync.Mutex
  for i, d := range data {
    wg.Add(1)
    go func(i, d int) {
      defer wg.Done()
      value := calculate(d)
      mu.Lock()
      result[i] = value
      mu.Unlock()
    }(i, d)
  }
  wg.Wait()
  fmt.Println("Result:", result)
}
func calculate(num int) int {
  time.Sleep(2 * time.Second)
  return num * num
}

在這個示例中，用 runtime.GOMAXPROCS(2) 將最大 CPU 核心數設置爲 2。

同時使用 sync.Mutex 對 result 切片進行保護，確保多個 Goroutine 同時寫入時不會發生數據競爭。

5. 總結

通過本文的講解和實例演示，瞭解了在 Go 語言中實現多核並行化的方法。

從基本的併發基礎、sync 包的使用，到 GOMAXPROCS 的設置，再到實際應用的多核並行計算，希望讀者能夠更全面地瞭解如何在 Go 語言中發揮硬件多核潛力，提高程序性能。

在實際開發中，根據具體情況選擇合適的併發控制手段，合理設置並行度，將是提高 Go 語言程序性能的關鍵之一。

本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/U9P8VVaCCh6Z8E8gGIKQ7Q