初探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)

  Salin selepas log masuk

  通过上述代码获得channel变量，我们可以对它执行发送与接收的操作。

• 只接收的channel

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

  Salin selepas log masuk

  通过上述代码获得channel变量，我们只能对它进行接收操作。

• 只发送的channel

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

  Salin selepas log masuk

  通过上述代码获得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 }

  Salin selepas log masuk

• 管道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 }

  Salin selepas log masuk

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

小结

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

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

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

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

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

Atas ialah kandungan terperinci 初探Go语言中的Goroutine和channel. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!