初探Go語言中的Goroutine與channel

這篇文章帶大家初步了解Go語言中的Goroutine和channel，希望對大家有幫助！

Go 語言的CSP 並發模型的實作包含兩個主要組成部分：一個是Goroutine，另一個是channel。本文將會介紹它們的基本用法和注意事項。

Goroutine

Goroutine 是Go 應用程式的基本執行單元，它是一種輕量級的用戶級線程，其底層是透過coroutine（協程）去實現的並發。眾所周知，協程是一種運行在用戶狀態的使用者線程，因此 Goroutine 也是被調度於 Go 程式運行時。

基本用法

語法：go 函數/方法

透過go 關鍵字函數/方法可以建立一個Goroutine。

程式碼範例：

import (
   "fmt"
   "time"
)

func printGo() {
   fmt.Println("具名函数")
}

type G struct {
}

func (g G) g() {
   fmt.Println("方法")
}

func main() {
   // 基于具名函数创建 goroutine
   go printGo()
   // 基于方法创建 goroutine
   g := G{}
   go g.g()
   // 基于匿名函数创建 goroutine
   go func() {
      fmt.Println("匿名函数")
   }()
   // 基于闭包创建 goroutine
   i := 0
   go func() {
      i++
      fmt.Println("闭包")
   }()
   time.Sleep(time.Second) // 避免 main goroutine 结束后，其创建的 goroutine 来不及运行，因此在此休眠 1 秒
}

執行結果：

闭包
具名函数
方法
匿名函数

當多個 Goroutine 存在時，它們的執行順序是不固定的。因此每次列印的結果都不相同。

由程式碼可知，透過go 關鍵字，我們可以基於具名函數 / 方法 建立goroutine，也可以基於匿名函數 / 閉包 建立goroutine。

那麼 Goroutine 是如何退出的呢？正常情況下，只要 Goroutine 函數執行結束，或執行返回，意味著 Goroutine 的退出。如果 Goroutine 的函數或方法有回傳值，在 Goroutine 退出時會將其忽略。

channel

channel 在 Go 並發模型中扮演者重要的角色。它可以用來實現 Goroutine 間的通信，也可以用來實現 Goroutine 間的同步。

channel 的基本操作

channel 是一種複合資料類型，宣告時需要指定channel 裡元素的類型。

宣告語法：var ch chan string

透過上述程式碼宣告一個元素類型為string 的channel，其只能存放string 類型的元素。 channel 是引用類型，必須初始化才能寫入數據，透過 make 的方式初始化。

import (
   "fmt"
)

func main() {
   var ch chan string
   ch = make(chan string, 1)
   // 打印 chan 的地址
   fmt.Println(ch)
   // 向 ch 发送 "Go" 数据
   ch <- "Go"
   // 从 ch 中接收数据
   s := <-ch
   fmt.Println(s) // Go
}

透過ch <- xxx 可以向channel 變數ch 發送數據，透過x := <- ch 可以從channel 變數ch 接收資料。

帶緩衝channel 與無緩衝channel

如果初始化#channel 時，不指定容量時，則建立的是一個無緩衝的channel：

ch := make(chan string)

無緩衝的channel 的發送與接收操作是同步的，在執行發送操作之後，對應Goroutine 將會阻塞，直到有另一個Goroutine 去執行接收操作，反之亦然。如果將發送操作和執行操作放在同一個 Goroutine 下進行，會發生什麼操作？看看下述程式碼：

import (
   "fmt"
)

func main() {
   ch := make(chan int)
   // 发送数据
   ch <- 1 // fatal error: all goroutines are asleep - deadlock!
   // 接收数据
   n := <-ch
   fmt.Println(n)
}

程式運行之後，會在ch <- 處得到fatal error，提示所有的Goroutine處於休眠狀態，也就是死鎖了。為避免這種情況，我們需要將 channel 的傳送操作和接收操作放到不同的 Goroutine 中執行。

import (
   "fmt"
)

func main() {
   ch := make(chan int)
   go func() {
      // 发送数据
      ch <- 1
   }()
   // 接收数据
   n := <-ch
   fmt.Println(n) // 1
}

由上述例子可以下結論：無緩衝channel 的發送與接收操作，一定要放在兩個不同的Goroutine 中進行，否則會發生deadlock 形象。

---

如果指定容量，則建立的是一個帶有緩衝的channel：

ch := make(chan string, 5)

有緩衝的channel 與無緩衝的chennel 有所區別，執行發送操作時，只要channel 的緩衝區未滿，Goroutine 不會掛起，直到緩衝區滿時，再向channel 執行發送操作，才會導致Goroutine 掛起。程式碼範例：

func main() {
   ch := make(chan int, 1)
   // 发送数据
   ch <- 1

   ch <- 2 // fatal error: all goroutines are asleep - deadlock!
}

聲明channel 的只發送類型和只接收類型

• 既能發送又能接收的channel

  ch := make(chan int, 1)

  透過上述程式碼獲得channel 變量，我們可以對它執行發送與接收的操作。

• 只接收的channel

  ch := make(<-chan int, 1)

  透過上述程式碼獲得channel 變量，我們只能對它進行接收操作。

• 只發送的channel

  ch := make(chan<- int, 1)

  透過上述程式碼獲得channel 變量，我們只能對它進行發送操作。

通常只发送 channel 类型和只接收 channel 类型，会被用作函数的参数类型或返回值：

func send(ch chan<- int) {
   ch <- 1
}

func recv(ch <-chan int) {
   <-ch
}

channel 的关闭

通过内置函 close(c chan<- Type)，可以对 channel 进行关闭。

• 在发送端关闭 channel

  在 channel 关闭之后，将不能对 channel 执行发送操作，否则会发生 panic，提示 channel 已关闭。

  func main() {
     ch := make(chan int, 5)
     ch <- 1
     close(ch)
     ch <- 2 // panic: send on closed channel
  }

• 管道 channel 之后，依旧可以对 channel 执行接收操作，如果存在缓冲区的情况下，将会读取缓冲区的数据，如果缓冲区为空，则获取到的值为 channel 对应类型的零值。

  import "fmt"
  
  func main() {
     ch := make(chan int, 5)
     ch <- 1
     close(ch)
     fmt.Println(<-ch) // 1
     n, ok := <-ch
     fmt.Println(n)  // 0
     fmt.Println(ok) // false
  }

• 如果通过 for-range 遍历 channel 时，中途关闭 channel 则会导致 for-range 循环结束。

小结

本文首先介绍了 Goroutine的创建方式以及其退出的时机是什么。

其次介绍了如何创建 channel 类型变量的有缓冲与无缓冲的创建方式。需要注意的是，无缓冲的 channel 发送与接收操作，需要在两个不同的 Goroutine 中执行，否则会发送 error。

接下来介绍如何定义只发送和只接收的 channel 类型。通常只发送 channel 类型和只接收 channel 类型，会被用作函数的参数类型或返回值。

最后介绍了如何关闭 channel，以及关闭之后的一些注意事项。

【相关推荐：Go视频教程、编程教学】

以上是初探Go語言中的Goroutine與channel的詳細內容。更多資訊請關注PHP中文網其他相關文章！