GoLang之使用channel

GoGo在努力

已于 2022-05-19 16:15:43 修改

阅读量1k

点赞数

分类专栏： GoLang 文章标签： golang

于 2022-04-05 18:57:40 首次发布

本文链接：https://blog.csdn.net/weixin_52690231/article/details/123969741

版权

GoLang 专栏收录该内容

87 篇文章 32 订阅

订阅专栏

GoLang之使用channel

注：本文以Go SDK v1.8进行讲解

1.接受命令

从一个通道中接收值。
<-ch 的意思是：从通道中把值取出来，把这个值给丢弃了，并不会把它赋值给其他的变量

x := <- ch // 从ch中接收值并赋值给变量x
<-ch       // 从ch中接收值，忽略结果

3.发送命令

将一个值发送到通道中。

ch <- 10 // 把10发送到ch中

4.关闭命令

我们通过调用内置的close函数来关闭通道。
如果你的管道不往里存值或者取值的时候一定记得关闭管道;
当通过通道发送有限的数据时，我们可以通过close函数关闭通道来告知从该通道接收值的goroutine停止等待
一个通道值是可以被垃圾回收掉的。通道通常由发送方执行关闭操作，并且只有在接收方明确等待通道关闭的信号时才需要执行关闭操作。它和关闭文件不一样，通常在结束操作之后关闭文件是必须要做的，但关闭通道不是必须的。

close(ch)

5.channel异常

5.1异常介绍

注意:
(1)nil channel指的是var 定义的，不是make定义的那种无缓冲的那种
(2)这里的发送是指写入值
(3)这个表格没有定义make无缓冲时候的3种情况
发送：阻塞
接受：阻塞
关闭：关闭成功，返回零值
(4)非空与没满一样
(5)当通道被关闭时，往该通道发送值会引发panic，从该通道里接收的值一直都是类型零值

5.2nil 接受

5.3nil 发送

5.4nil 关闭

在这里插入图片描述

5.5空接受

5.5空发送

5.6空关闭

5.7满了接受

func main() {
	ch := make(chan int, 2)
	ch <- 1
	ch <- 2
	var a int = <-ch
	fmt.Println(a) //输出：1
}

5.8满了发送

5.9满了关闭

5.10make无缓冲接受

5.11make无缓冲发送

5.12make无缓冲关闭

6.var创建

声明通道类型变量的格式如下：
通道类型的空值是nil；nil：是指没有做初始化的通道

var 变量名称 chan 元素类型
var ch1 chan int   // 声明一个传递整型的通道
var ch2 chan bool  // 声明一个传递布尔型的通道
var ch3 chan []int // 声明一个传递int切片的通道

func main() {
	var ch chan int
	if ch == nil {
		fmt.Println("ch是nil") //ch是nil
	} else {
		fmt.Println("ch不是nil")
	}
	fmt.Println(ch)//<nil>
}

7.make创建不指定缓冲区

7.1错误使用

func main() {
	ch := make(chan int)
	if ch == nil {
		fmt.Println("ch是nil")
	} else {
		fmt.Println("ch不是nil") //ch不是nil
	}
	fmt.Println(ch) //0xc000018060
}

无缓冲的通道称为阻塞的通道
为什么会出现deadlock错误呢？
因为我们使用ch := make(chan int)创建的是无缓冲的通道，无缓冲的通道只有在有人接收值的时候才能发送值。就像你住的小区没有快递柜和代收点，快递员给你打电话必须要把这个物品送到你的手中，简单来说就是无缓冲的通道必须有接收才能发送；
上面的代码会阻塞在ch <- 10这一行代码形成死锁，那如何解决这个问题呢？
有两个方法
方法(1)是启用一个goroutine去接收值
方法(2)是设置有缓冲区的通道

7.2无goroutine错误解决

在x :=<-ch的时候就已经错了

7.3有goroutine错误解决

不能以下写，会犯错
原因是:在ch <-10的时候就已经出错了，一直没去接受的

7.4有goroutine正确解决方法1

无缓冲通道上的发送操作会阻塞，直到另一个goroutine在该通道上执行接收操作，这时值才能发送成功，两个goroutine将继续执行；
使用无缓冲通道进行通信将导致发送和接收的goroutine同步化。因此，无缓冲通道也被称为同步通道

附：

在这里插入图片描述

7.5有goroutine正确解决方法2

还有另外一种解决上面死锁问题的方法，那就是使用有缓冲区的通道。我们可以在使用 make 函数初始化通道时，可以为其指定通道的容量，例如：
只要通道的容量大于零，那么该通道就属于有缓冲的通道，通道的容量表示通道中最大能存放的元素数量。当通道内已有元素数达到最大容量后，再向通道执行发送操作就会阻塞，除非有从通道执行接收操作。就像你小区的快递柜只有那么个多格子，格子满了就装不下了，就阻塞了，等到别人取走一个快递员就能往里面放一个。
我们可以使用内置的len函数获取通道内元素的数量，使用cap函数获取通道的容量，虽然我们很少会这么做。

func main() {
	ch := make(chan int, 1) // 创建一个容量为1的有缓冲区通道
	ch <- 10
	fmt.Println("发送成功")
}

8.make创建指定缓冲区

带缓冲区的通道又成为"异步通道"

9.var结合make创建不指定缓冲区

声明的通道类型变量需要使用内置的make函数初始化之后才能使用。具体格式如下：
注：channel的缓冲大小是可选的。

make(chan 元素类型, [缓冲大小])

10.var结合make创建指定缓冲区

11.接受返回两个参数

当向通道中发送完数据时，我们可以通过close函数来关闭通道。当一个通道被关闭后，再往该通道发送值会引发panic，从该通道取值的操作会先取完通道中的值。通道内的值被接收完后再对通道执行接收操作得到的值会一直都是对应元素类型的零值。那我们如何判断一个通道是否被关闭了呢？
对一个通道执行接收操作时支持使用如下多返回值模式。
value, ok := <- ch
其中：
value：从通道中取出的值，如果通道被关闭则返回对应类型的零值。
ok：通道ch关闭时返回 false，否则返回 true。

12.close函数应用

有close

无close

13.channel结合grountine

0+4+(-9)=-5
7+2+8=17

14.range结合close遍历channel

通常我们会选择使用for range循环从通道中接收值，当通道被关闭后，会在通道内的所有值被接收完毕后会自动退出循环。上面那个示例我们使用for range改写后会很简洁。
注意：目前Go语言中并没有提供一个不对通道进行读取操作就能判断通道是否被关闭的方法。不能简单的通过len(ch)操作来判断通道是否被关闭。

func f3(ch chan int) {
	for v := range ch {
		fmt.Println(v)
	}
}

15.声明与初始化单向channel

单向通道一般用在向函数传参的时候，限定某个通道在函数中只能取值或者只能存值;
有的时候我们会将通道作为参数在多个任务函数间传递，很多时候我们在不同的任务函数中使用通道都会对其进行限制，比如限制通道在函数中只能发送或只能接收;

单向通道示例

16.单向通道

在某些场景下我们可能会将通道作为参数在多个任务函数间进行传递，通常我们会选择在不同的任务函数中对通道的使用进行限制，比如限制通道在某个函数中只能执行发送或只能执行接收操作。想象一下，我们现在有Producer和Consumer两个函数，其中Producer函数会返回一个通道，并且会持续将符合条件的数据发送至该通道，并在发送完成后将该通道关闭。而Consumer函数的任务是从通道中接收值进行计算，这两个函数之间通过Processer函数返回的通道进行通信。完整的示例代码如下。

ackage main

import (
	"fmt"
)

// Producer 返回一个通道
// 并持续将符合条件的数据发送至返回的通道中
// 数据发送完成后会将返回的通道关闭
func Producer() chan int {
	ch := make(chan int, 2)
	// 创建一个新的goroutine执行发送数据的任务
	go func() {
		for i := 0; i < 10; i++ {
			if i%2 == 1 {
				ch <- i
			}
		}
		close(ch) // 任务完成后关闭通道
	}()

	return ch
}

// Consumer 从通道中接收数据进行计算
func Consumer(ch chan int) int {
	sum := 0
	for v := range ch {
		sum += v
	}
	return sum
}

func main() {
	ch := Producer()

	res := Consumer(ch)
	fmt.Println(res) // 25

}

从上面的示例代码中可以看出正常情况下Consumer函数中只会对通道进行接收操作，但是这不代表不可以在Consumer函数中对通道进行发送操作。作为Producer函数的提供者，我们在返回通道的时候可能只希望调用方拿到返回的通道后只能对其进行接收操作。但是我们没有办法阻止在Consumer函数中对通道进行发送操作。
Go语言中提供了单向通道来处理这种需要限制通道只能进行某种操作的情况。
其中，箭头<-和关键字chan的相对位置表明了当前通道允许的操作，这种限制将在编译阶段进行检测。另外对一个只接收通道执行close也是不允许的，因为默认通道的关闭操作应该由发送方来完成。

<- chan int // 只接收通道，只能接收不能发送
chan <- int // 只发送通道，只能发送不能接收

我们使用单向通道将上面的示例代码进行如下改造。

// Producer2 返回一个接收通道
func Producer2() <-chan int {
	ch := make(chan int, 2)
	// 创建一个新的goroutine执行发送数据的任务
	go func() {
		for i := 0; i < 10; i++ {
			if i%2 == 1 {
				ch <- i
			}
		}
		close(ch) // 任务完成后关闭通道
	}()

	return ch
}

// Consumer2 参数为接收通道
func Consumer2(ch <-chan int) int {
	sum := 0
	for v := range ch {
		sum += v
	}
	return sum
}

func main() {
	ch2 := Producer2()
  
	res2 := Consumer2(ch2)
	fmt.Println(res2) // 25
}

这一次，Producer函数返回的是一个只接收通道，这就从代码层面限制了该函数返回的通道只能进行接收操作，保证了数据安全。很多读者看到这个示例可能会觉着这样的限制是多余的，但是试想一下如果Producer函数可以在其他地方被其他人调用，你该如何限制他人不对该通道执行发送操作呢？并且返回限制操作的单向通道也会让代码语义更清晰、更易读。
在函数传参及任何赋值操作中全向通道（正常通道）可以转换为单向通道，但是无法反向转换。

var ch3 = make(chan int, 1)
ch3 <- 10
close(ch3)
Consumer2(ch3) // 函数传参时将ch3转为单向通道

var ch4 = make(chan int, 1)
ch4 <- 10
var ch5 <-chan int // 声明一个只接收通道ch5
ch5 = ch4          // 变量赋值时将ch4转为单向通道
<-ch5

17.通道误用示例

接下来，我们将展示两个因误用通道导致程序出现 bug 的代码片段，希望能够加深读者对通道操作的印象。

示例1
将下述代码编译执行后，匿名函数所在的 goroutine 并不会按照预期在通道被关闭后退出。因为task := <- ch的接收操作在通道被关闭后会一直接收到零值，而不会退出。此处的接收操作应该使用task, ok := <- ch，通过判断布尔值ok为假时退出；或者使用select 来处理通道。

// demo1 通道误用导致的bug
func demo1() {
	wg := sync.WaitGroup{}

	ch := make(chan int, 10)
	for i := 0; i < 10; i++ {
		ch <- i
	}
	close(ch)

	wg.Add(3)
	for j := 0; j < 3; j++ {
		go func() {
			for {
				task := <-ch
				// 这里假设对接收的数据执行某些操作
				fmt.Println(task)
			}
			wg.Done()
		}()
	}
	wg.Wait()
	}

示例2
各位读者阅读下方代码片段，尝试找出其中存在的问题。
下述代码片段可能导致 goroutine 泄露（goroutine 并未按预期退出并销毁）。由于 select 命中了超时逻辑，导致通道没有消费者（无接收操作），而其定义的通道为无缓冲通道，因此 goroutine 中的ch <- "job result"操作会一直阻塞，最终导致 goroutine 泄露。

// demo2 通道误用导致的bug
func demo2() {
	ch := make(chan string)
	go func() {
		// 这里假设执行一些耗时的操作
		time.Sleep(3 * time.Second)
		ch <- "job result"
	}()

	select {
	case result := <-ch:
		fmt.Println(result)
	case <-time.After(time.Second): // 较小的超时时间
		return
	}
}