一文初探 Goroutine 与 channel基本用法

 更新时间:2023年02月02日 08:59:12   作者:陈明勇  
这篇文章主要为大家介绍了一文初探 Goroutine 与 channel基本用法详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪

前言

本文介绍的内容是 Go 并发模块的两个重要角色 → goroutinechannel。如果本文对你有帮助,不妨点个赞,如果你是 Go 语言初学者,不妨点个关注,一起成长一起进步,如果本文有错误的地方,欢迎指出!

Go 语言的 CSP 并发模型的实现包含两个主要组成部分:一个是 Goroutine,另一个是 channel。本文将会介绍它们的基本用法和注意事项。

Goroutine

GoroutineGo 应用的基本执行单元,它是一种轻量的用户级线程,其底层是通过 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

通过上述代码声明一个元素类型为 stringchannel,其只能存放 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语言题解LeetCode1160拼写单词示例详解

    go语言题解LeetCode1160拼写单词示例详解

    这篇文章主要为大家介绍了go语言题解LeetCode1160拼写单词示例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2022-12-12
  • 提高golang源码阅读效率的六个高级技巧

    提高golang源码阅读效率的六个高级技巧

    随着业务的发展,自己对代码的审美的改变,我们不断的迭代这些代码,代码量可以说是与日俱增,代码的某些结构也会发生大大小的改变,这些都要求我们在阅读代码的时候,需要更快的效率和技巧
    2024-01-01
  • Golang并发编程深入分析

    Golang并发编程深入分析

    golang中的并发,是函数相互独立运行的能力,goroutines是并发运行的函数。golang提供了goroutines作为并发处理的一种方式
    2022-11-11
  • Golang 实现 RTP音视频传输示例详解

    Golang 实现 RTP音视频传输示例详解

    这篇文章主要为大家介绍了Golang实现RTP音视频传输的示例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2022-07-07
  • 解读unsafe.Pointer和uintptr的区别

    解读unsafe.Pointer和uintptr的区别

    这篇文章主要介绍了解读unsafe.Pointer和uintptr的区别及说明,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2023-02-02
  • go强制类型转换type(a)以及范围引起的数据差异

    go强制类型转换type(a)以及范围引起的数据差异

    这篇文章主要为大家介绍了go强制类型转换type(a)以及范围引起的数据差异,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2023-10-10
  • Golang实现反向代理的示例代码

    Golang实现反向代理的示例代码

    这篇文章主要为大家学习介绍了如何利用Golang实现反向代理,文中的示例代码讲解详细,具有一定的学习价值,感兴趣的小伙伴可以跟随小编一起了解一下
    2023-07-07
  • go并发利器sync.Once使用示例详解

    go并发利器sync.Once使用示例详解

    这篇文章主要为大家介绍了go并发利器sync.Once使用示例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2023-03-03
  • Go ORM的封装解决方式详解

    Go ORM的封装解决方式详解

    这篇文章主要为大家介绍了Go ORM的封装解决方式详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2023-01-01
  • 一文秒懂Go 编写命令行工具的代码

    一文秒懂Go 编写命令行工具的代码

    这篇文章主要介绍了一文秒懂Go 编写命令行工具的代码,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2021-01-01

最新评论