go语言并发编程(四) ——再探管道

简介: go语言并发编程(四) ——再探管道

单向管道

什么是单向管道

在Go语言中,管道有两种类型:双向管道与单向管道.双向管道指的是可以读也可以写,能在管道两边进行数据的读写操作,而单向管道指的是只能在管道的一边进行操作,我们手动创建一个只读/写的管道意义不大,一般是用于函数的参数传递或是作为返回值出现,例如我们用来关闭协程的管道的函数:

func close(c <- chan T

双向管道可以转换为单向管道,反过来则不可以。通常情况下,将双向管道传给某个协程或函数并且不希望它读取/发送数据,就可以用到单向管道来限制另一方的行为。

func main() {
ch := make(chan int, 1)
go write(ch)
fmt.Println(<-ch)
}
func write(ch chan<- int) {
// 只能对管道发送数据
ch <- 1
}

当然读管道同理

for range 遍历管道

在Go语言中我们可以基于for range来遍历读取管道中的数据,比如下面的这个例子:

package main
import "fmt"
func main() {
  ch := make(chan int, 10)
  defer close(ch)
  for i := 0; i < 10; i++ {
    ch <- i
  }
  for i := 0; i < 10; i++ {
    fmt.Println(<-ch)
  }
}

输出为:

0
1
2
3
4
5
6
7
8
9

其实通常来说当我们使用 for range来遍历数据结构的时候,一般会有两个返回值:一个是索引,另一个则是该索引对应的位置的元素值,但是对于管道而言,有且仅有一个返回值,就是缓冲区的元素值,for range会遍历读取管道缓冲区中的元素,当管道缓冲区为空时,就会阻塞等待,直到有其他协程向管道中写入数据才会继续读取数据。

注意:关闭管道的操作尽量在发送数据的那一方进行,而不要在接收方关闭管道,因为大多数情况下接收方只知道接收数据,并不知道该在什么时候关闭管道。

select

什么是select

select在Linux系统中一般用于IO多路复用,类似的,在Go语言中,select是一种管道多路复用的控制结构,而到底什么是多路复用,简单的用一句话来概括的话就是:在某一时刻,同时监测多个元素是否可用,而被监测的可以是网络请求,文件IO等,而在Go语言中的select则用于检测管道是否可用,如果可用,则读取管道中的数据,否则阻塞等待。

接下来我们来看一个简单的select的例子:

package main
import "fmt"
func main() {
  ch1, ch2, ch3 := make(chan bool), make(chan bool), make(chan bool)
  defer func() {
    close(ch1)
    close(ch2)
    close(ch3)
  }()
  select {
  case n, ok := <-ch1:
    fmt.Println(n, ok)
  case n, ok := <-ch2:
    fmt.Println(n, ok)
  case n, ok := <-ch3:
    fmt.Println(n, ok)
  default:
    fmt.Println("default")
  }
}

与switch相似,select由多个case和一个default组成,default分支可以忽略,而每一个case只能操作一种管道,并且只能进行一种操作,要么读要么写,当有多个case可用的时候,select会随机选择一个case来执行,如果所有case都不可用,就会执行default分支,倘若没有default分支,将会阻塞等待,直到至少有一个case可用。所以上面的输出结果

为:

default

不过上述的的例子中,执行完对应分支以后,主协程就直接退出了,所以如果我们想一直检测管道的话,要给select语句加上一个死循环代码来保证select可以一直监测管道:

package main
import "fmt"
func main() {
  ch1, ch2, ch3 := make(chan int), make(chan int), make(chan int)
  defer func() {
    close(ch1)
    close(ch2)
    close(ch3)
  }()
  go Send(ch1)
  go Send(ch2)
  go Send(ch3)
  for {
    select {
    case n, ok := <-ch1:
      fmt.Println(n, ok)
    case n, ok := <-ch2:
      fmt.Println(n, ok)
    case n, ok := <-ch3:
      fmt.Println(n, ok)
    }
  }
}
func Send(ch chan<- int) {
  for i := 0; i < 3; i++ {
    ch <- i
  }
}

这样确实三个管道都能用上了,但是死循环+select会导致主协程永久阻塞,所以可以将其单独放到新协程中,并且加上一些其他的逻辑。

package main
import (
  "fmt"
  "time"
)
func main() {
  chan1, chan2, chan3 := make(chan int), make(chan int), make(chan int)
  l := make(chan struct{})
  defer func() {
    close(chan1)
    close(chan2)
    close(chan3)
  }()
  go Send(chan1)
  go Send(chan2)
  go Send(chan3)
  go func() {
  Loop:
    for {
      select {
      case n, ok := <-chan1:
        fmt.Println("A", n, ok)
      case n, ok := <-chan2:
        fmt.Println("B", n, ok)
      case n, ok := <-chan3:
        fmt.Println("C", n, ok)
      case <-time.After(1 * time.Second): //设置超时时间
        break Loop //
      }
    }
    l <- struct{}{}
  }()
  <-l
}
func Send(ch chan<- int) {
  for i := 0; i < 3; i++ {
    ch <- i
  }
}

上例中通过for循环配合select来一直监测三个管道是否可以用,并且第四个case是一个超时管道,超时过后便会退出循环,结束子协程。最终输出如下:

输出结果为:

A 0 true
B 0 true
B 1 true
A 1 true
A 2 true
C 0 true
B 2 true
C 1 true
C 2 true

超时机制

在是一个例子中我们用到了time.After函数,这个函数的返回值是一个只读的管道,我们可以利用它来实现一个比较简单的超时机制,比如下面这个例子:

package main
import "time"
func main() {
  ch := make(chan struct{}, 1)
  go func() {
    time.Sleep(time.Second * 2)
    ch <- struct{}{}
  }()
Loop:
  for {
    select {
    case <-ch:
      println("ok")
    case <-time.After(time.Second):
      println("超时")
      break Loop
    }
  }
}

输出为:

超时

注意:在select的case中对值为nil的管道进行操作的话,并不会导致阻塞,该case则会被忽略,永远也不会被执行

文章知识点与官方知识档案

相关文章
|
6天前
|
存储 JSON 监控
Viper,一个Go语言配置管理神器!
Viper 是一个功能强大的 Go 语言配置管理库,支持从多种来源读取配置,包括文件、环境变量、远程配置中心等。本文详细介绍了 Viper 的核心特性和使用方法,包括从本地 YAML 文件和 Consul 远程配置中心读取配置的示例。Viper 的多来源配置、动态配置和轻松集成特性使其成为管理复杂应用配置的理想选择。
23 2
|
4天前
|
Go 索引
go语言中的循环语句
【11月更文挑战第4天】
13 2
|
4天前
|
Go C++
go语言中的条件语句
【11月更文挑战第4天】
16 2
|
7天前
|
监控 Go API
Go语言在微服务架构中的应用实践
在微服务架构的浪潮中,Go语言以其简洁、高效和并发处理能力脱颖而出,成为构建微服务的理想选择。本文将探讨Go语言在微服务架构中的应用实践,包括Go语言的特性如何适应微服务架构的需求,以及在实际开发中如何利用Go语言的特性来提高服务的性能和可维护性。我们将通过一个具体的案例分析,展示Go语言在微服务开发中的优势,并讨论在实际应用中可能遇到的挑战和解决方案。
|
4天前
|
Go
go语言中的 跳转语句
【11月更文挑战第4天】
12 4
|
4天前
|
JSON 安全 Go
Go语言中使用JWT鉴权、Token刷新完整示例,拿去直接用!
本文介绍了如何在 Go 语言中使用 Gin 框架实现 JWT 用户认证和安全保护。JWT(JSON Web Token)是一种轻量、高效的认证与授权解决方案,特别适合微服务架构。文章详细讲解了 JWT 的基本概念、结构以及如何在 Gin 中生成、解析和刷新 JWT。通过示例代码,展示了如何在实际项目中应用 JWT,确保用户身份验证和数据安全。完整代码可在 GitHub 仓库中查看。
18 1
|
6天前
|
Go 调度 开发者
探索Go语言中的并发模式:goroutine与channel
在本文中,我们将深入探讨Go语言中的核心并发特性——goroutine和channel。不同于传统的并发模型,Go语言的并发机制以其简洁性和高效性著称。本文将通过实际代码示例,展示如何利用goroutine实现轻量级的并发执行,以及如何通过channel安全地在goroutine之间传递数据。摘要部分将概述这些概念,并提示读者本文将提供哪些具体的技术洞见。
|
10天前
|
JavaScript Java Go
探索Go语言在微服务架构中的优势
在微服务架构的浪潮中,Go语言以其简洁、高效和并发处理能力脱颖而出。本文将深入探讨Go语言在构建微服务时的性能优势,包括其在内存管理、网络编程、并发模型以及工具链支持方面的特点。通过对比其他流行语言,我们将揭示Go语言如何成为微服务架构中的一股清流。