golang并发编程-04-通道-01-基本使用/缓冲通道/非缓冲通道

已于 2023-07-06 09:22:18 修改
阅读量766 收藏 2
点赞数 2
分类专栏： # go语言并发编程 文章标签： golang Go语言 并发编程 缓冲通道 非缓冲通道
于 2022-05-09 09:43:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xingzuo_1840/article/details/124531929
版权

文章目录

1. 通道的基本使用

  • 同一时间，仅允许一个协程对其写入/读出
  • 严格排序，先进先出
  • 通道元素有原子性

比如：放进一个 []string，也不能单次取出一个 string

  • 已被接收的元素值会立刻被从通道中删除

1.1 声明通道

  • 语法
type 通道名 chan 通道中数据类型
  • 示例
type ch1 chan int
  • 值表示法
    通道类型是引用类型，所以被初始化之前它的值一定是nil。

1.2 初始化通道

1）初始化方法

  • 语法
make(chan 通道中数据类型[, N])

N表示同一时刻最多可以容纳N个元素值

  • 示例
make (chan int,10)

2）缓冲/非缓冲通道

  • 缓冲通道：始化时给定了第二个参数的通道
  • 非缓冲通道：初始化时未给定第二个参数

一个通道类型的值的缓冲容量是固定不变的，发送给非缓冲通道的的元素值必须被立刻取走。

1.3 发送元素值

  • 语法
通道名 <- 变量名|值
  • 示例
c <- "aaa"
  • 示例

input函数将数组names传入通道

func input( c chan string) {
	names := []string{"关羽", "张飞", "赵云", "马超","黄忠"}
	for _,x := range names {
		c <- x
	}
	close(c)
}

func main() {
	c := make(chan string, 10)
	input(c)

	for i := range c {
		fmt.Printf("hello %s \n",i)
	}
	time.Sleep(3*time.Second)
}

  • 通道写满
    如果通道写满，向通道中写入的协程将被阻塞，直到通道中数据被接收时该协程被唤醒。

  • 传入通道的值仅是副本
    变量将值传给通道之后，变量值变化与通道中数据无关。

func main() {
  name := "关羽"
  c := make(chan string,3)
  defer close(c)
  c <- name
  name = "张飞"
  if i,ok := <- c;ok {
	  fmt.Println("channel :",i)
	  fmt.Println("name :",name)
  }
}

输出

channel : 关羽
name : 张飞

可见 name 改为张飞之后，channel里的值依然是关羽。

1.4 接收元素值

  • 语法
变量名[,布尔值] := <-通道名

示例

name := <- c

或

name,ok := <- c

ok值：如果读出数据为true ，未读出为false（比如通道中没有数据了）
ok值的作用：作为一个布尔值，可用作之后的if判断，如下：

		name,ok := <- c
		if ok{
			go fmt.Println(name)
		}else {
			break
		}
  • 示例
func input( c chan string) {
	names := []string{"关羽", "张飞", "赵云", "马超","黄忠"}
	for _,x := range names {
		c <- x
	}
	close(c)
}

func main() {
	c := make(chan string, 10)
	input(c)
	for {
		name,ok := <- c
		if ok{
			go fmt.Println(name)
		}else {
			break
		}
	}
	time.Sleep(3*time.Second)
}

打印结果

没有顺序，五个协程谁先打印出结果看命。

黄忠
关羽
张飞
赵云
马超
  • 从未初始化的通道接收数据

此时通道会被永远阻塞

1.5 关闭通道

  • 语法
close(通道名)

示例

close(c1)

  • 关闭时机
    建议在输入端关闭
    通道关闭之后仍可以读出

  • 示例

一个通道
两个函数 input()写，output()读,
两个协程分别执行读写函数
关闭通道在写函数中

func input( c chan string) {
	names := []string{"关羽", "张飞", "赵云", "马超","黄忠"}
	for _,x := range names {
		c <- x
	}
	close(c)
}
func output (c chan string ){
	for i := range c {
			fmt.Println("hello ",i)
	}
}
func main() {
	c := make(chan string, 1)
	go input(c)
	go output(c)
	time.Sleep(3*time.Second)
}

1.6 通道的长度与容量

1）概念

  • len() ：表示通道中目前有多少个元素
  • cap()：表示通道可以容纳多少个元素

2）演示

我们将上例修改一下，初始化的时候，设定通道容量为8，打印长度和容量，然后将读取调用注释掉。

func input( c chan string) {
	names := []string{"关羽", "张飞", "赵云", "马超","黄忠"}
	for _,x := range names {
		c <- x
	}
	close(c)
}
func output (c chan string ){
	for i := range c {
			fmt.Println("hello ",i)
	}
}
func main() {
	c := make(chan string,8)
	input(c)
	//output(c)
	fmt.Println("通道长度是： ",len(c))
	fmt.Println("通道容量是： ",cap(c))
	time.Sleep(3*time.Second)
}

输出

通道长度是：  5
通道容量是：  8

输入的5个元素都停留在通道中，所以长度是5。
而通道容量是我们初始化时候的容量。

  • 将读取打开
func main() {
	c := make(chan string,8)
	input(c)
	fmt.Println("通道长度是： ",len(c))
	fmt.Println("通道容量是： ",cap(c))
	output(c)
	fmt.Println("读取后通道长度是： ",len(c))
	fmt.Println("读取后通道容量是： ",cap(c))
	time.Sleep(3*time.Second)
}

输出

通道长度是：  5
通道容量是：  8
hello  关羽
hello  张飞
hello  赵云
hello  马超
hello  黄忠
读取后通道长度是：  0
读取后通道容量是：  8

可见，读取后通道长度变为0，而通道容量不变。（有兴趣的话你可以打印每次写入/读取时的通道长度）

2. 单项通道

2.1 发送通道和接收通道

  • 概念：单向通道可分为接收通道和发送通道
  • 作用：一个仅发送，一个仅接收（否则报错）。
  • 语法

发送通道：

通道名 chan<- 传入数据类型

传出通道：

通道名 <-chan 传出数据类型
  • 示例
var in chan<- string
var out <-chan string
  • 意义：
    在函数中将通道定义为单项，避免函数对通道造成污染。

2.2 使用单项通道

示例1

说明：

  1. 定义输入函数，形参为发送通道
  2. 定义传出函数，形参为接收通道
  3. 主函数中定义一个双向通道
  4. 主函数调用传入函数，该通道为实参（该函数中为发送通道）。
  5. 主函数调用传出函数，该通道位实参（该函数中为接收通道）。
  • 完整代码如下
func main() {
	chan1 := make(chan string,10)
	go input(chan1)  //调用发送通道函数
	go output(chan1) //调用接收通道函数
	time.Sleep(1*time.Second)
}

func input(in chan<- string) {
	names := []string{"关羽", "张飞", "赵云", "马超","黄忠"}
	for _,i := range names {
		in <- i
	}
	close(in)
}

func output(out <-chan string) {
	for i := range out {
		fmt.Println("hello ", i)
	}
}
  • 输出
hello  关羽
hello  张飞
hello  赵云
hello  马超
hello  黄忠
  • 不使用协程
    作为缓冲通道，只要通道容量给的足够，我们可以不使用协程，而非缓冲通道则必须使用协程了。
func main() {
	chan1 := make(chan string,10)
	go input(chan1)  //调用发送通道函数
	go output(chan1) //调用接收通道函数
	time.Sleep(1*time.Second)
}

示例2

说明：
如果我们要求传入传出两个通道分开（chan1、chan2），那么我们还需要用一个函数将chan1的数据写入chan2。

  1. 定义输入函数，形参为发送通道
  2. 定义传出函数，形参为接收通道
  3. 定义转换函数，形参为发送函数和接收函数
  4. 主函数中定义两个双向通道chan1、chan2
  5. 主函数调用传入函数，以chan1位实参（chan1为发送通道）。
  6. 主函数调用传出函数，以chan2位实参。（chan2为接收通道）
  7. 主函数调用转换函数，实参和调用传出、传入函数相反（即：chan2为发送通道，chan1为接收通道），从而将chan1的数据写入chan2.
  • 完整示例
func main() {
	chan1 := make(chan string)
	chan2 := make(chan string)
	go input(chan1)  //调用发送通道函数
	go in2out(chan2, chan1) //将发送通道的数据写入接收通道
	go output(chan2) //调用接收通道
	time.Sleep(1*time.Second)函数
}

func input(in chan<- string) {
	names := []string{"关羽", "张飞", "赵云", "马超","黄忠"}
	for _,i := range names {
		in <- i
	}
	close(in)
}

func output(out <-chan string) {
	for i := range out {
		fmt.Println("hello ", i)
	}
}

func in2out(out chan<- string, in <-chan string) {
	for i:= range in {
		out <- i
	}
	close(out)
}

3. 循环和语句中的通道

3.1 for循环

  • 前边示例一直在用，注意一下通道未初始化的问题，其他不多说了。

  • 另外，下边这个示例读写我没用协程，注意通道容量要给够，否则报错。（当然使用协程不存在这个问题）

package main

import (
	"errors"
	"fmt"
	"time"
)

func input( c chan string) error{
	names := []string{"关羽", "张飞", "赵云", "马超","黄忠"}
	for _,x := range names {
		if c == nil {
			return errors.New("通道为nil")
		}
		c <- x
	}
	close(c)
	return nil
}
func output (c chan string ) error{
	if c == nil {
		return errors.New("通道为nil")
	}
	for i := range c {
		fmt.Println("hello ",i)
	}
	return nil
}
func main() {
	c := make(chan string, 8)
	//var c chan string  //注释掉初始化，打开本行看报错
	err := input(c)
	if err != nil {
		fmt.Println(err)
	}
	err = output(c)
	if err != nil {
		fmt.Println(err)
	}
	time.Sleep(3*time.Second)
}

3.2 select语句

作用：通道的选择

示例

  • 要求：
    1）两个协程分别向两个通道中写入蜀将和魏将的名字
    2）将结果分别打印出来。

  • 思路：
    创建两个函数，分别向两个通道c1、c2中写。
    主函数启动两个协程，分别调用两个写函数。
    主函数启动一个协程（避免for的死循环）分别打印两个通道中的数据

  • 代码：

func inputShu( c chan string) {
	names := []string{"关羽", "张飞", "赵云", "马超","黄忠"}
	for _,x := range names {
		c <- x
	}
	close(c)
}

func inputWei( c chan string) {
	names := []string{"张辽", "乐进", "于禁", "张合","徐晃"}
	for _,x := range names {

		c <- x
	}
	close(c)
}

func main() {

	c1 := make(chan string,8)
	c2 := make(chan string,8)

	go inputShu(c1)
	go inputWei(c2)

	go func() {
		for {
			time.Sleep(500*time.Millisecond)
			select {
			case msg1,ok := <-c1:
				//if msg1 == ""{continue}
				if ok {
					fmt.Println("蜀将： ", msg1)
				}
			case msg2,ok := <-c2:
				if ok {
					fmt.Println("魏将： ", msg2)
				}
			default:
				fmt.Println("hello world")
			}
		}
	}()
    time.Sleep(10*time.Second)
}

输出：

蜀将：  关羽
魏将：  张辽
蜀将：  张飞
魏将：  乐进
蜀将：  赵云
蜀将：  马超
魏将：  于禁
蜀将：  黄忠
魏将：  张合
魏将：  徐晃

4 非缓冲通道

4.1 概述

概念：
容量设置成0，或者直接忽略对容量的设置的通道

特点：
只能同步的传递发送给它的元素值

非缓冲通道的“happens before”原则：

  • 向此类通道发送元素值的操作会被阻塞，直到至少有一个针对该通道的接收操作开始进行为止。
  • 从此类通道接收元素值的操作会被阻塞，直到至少有一个针对该通道的发送操作开始进行为止。
  • 针对非缓冲通道的接收操作会在与之相对应的发送操作完成之前完成。

发送操作会等待接收操作完成后结束

func main() {
	unbufChan := make(chan string)
	go func() {
		fmt.Println("( • - •) 孔明在睡觉")
		time.Sleep(5*time.Second)
		fmt.Println("很久以后~~~~~~~孔明睡醒了")
		massage := <-unbufChan
		fmt.Printf("( • - •) 孔明收到了 《%s》\n", massage)
	}()
	massage:= "先生请出山"
	fmt.Printf("[ x - x] 主公来了 %s\n", massage)
	unbufChan <- massage
	fmt.Println("[ x - x] 主公走了")
}

输出：

[ x - x] 主公来了 先生请出山
( • - •) 孔明在睡觉
很久以后~~~~~~~孔明睡醒了
( • - •) 孔明收到了 《先生请出山》
[ x - x] 主公走了

执行可见，主函数的输入等待到协程读取通道之后才结束。

4.2 单向的非缓冲通道

和缓冲通道中的使用几乎相同
值得关注的是：

  • 非缓冲通道必须使用协程
  • 缓冲通道在容量够大的情况下，一个协程就可以完成读写。
func main() {
	chan1 := make(chan string)
	input(chan1)  //调用发送通道函数
	output(chan1) //调用接收通道函数
	time.Sleep(1*time.Second)
}

func input(in chan<- string) {
	names := []string{"关羽", "张飞", "赵云", "马超","黄忠"}
	for _,i := range names {
		in <- i
	}
	close(in)
}

func output(out <-chan string) {
	for i := range out {
		fmt.Println("hello ", i)
	}
}

4.3 for循环和select的非缓冲通道

若同是 for循环+协程的应用，通道是否有缓冲，在使用上并没有太大区别

func inputShu( c chan string) {
	names := []string{"关羽", "张飞", "赵云", "马超","黄忠"}
	for _,x := range names {
		c <- x
	}
	close(c)
}

func inputWei( c chan string) {
	names := []string{"张辽", "乐进", "于禁", "张合","徐晃"}
	for _,x := range names {

		c <- x
	}
	close(c)
}

func main() {

	c1 := make(chan string)
	c2 := make(chan string)

	go inputShu(c1)
	go inputWei(c2)

	func() {
		for {
			time.Sleep(500*time.Millisecond)
			select {
			case msg1,ok := <-c1:
				//if msg1 == ""{continue}
				if ok {
					fmt.Println("蜀将： ", msg1)
				}
			case msg2,ok := <-c2:
				if ok {
					fmt.Println("魏将： ", msg2)
				}
			default:
				fmt.Println("hello world")
			}
		}
	}()
	time.Sleep(10*time.Second)
}

玄德公笔记
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
golang基础之通道
叱咤少帅的博客
10-17 471
golang基础之通道
golang并发编程的实现
12-23
go main函数的执行本身就是一个协程，当使用go关键字的时候，就会创建一个新的协程 channel channel 管道，用于在多个协程之间传递信号 无缓存管道 当对无缓冲通道写的时候，会一直阻塞等到某个协程对这个缓冲通道读 阻塞场景： 通道中无数据，但执行读通道。 通道中无数据，向通道写数据，但无协程读取。 综上，无缓存通道的读写必须同时存在，且读写分别在两个不同的协程 func main(){ ch := make(chan int) go func(ch chan int){ ch <-222 }(ch) println(<-ch) } 有缓冲管道 有缓存时可以向通道中写入数据后直
go语言通道channel 的用法汇总
weixin_34449966的博客
03-18 2083
channel的定义：make(chan string): ch:= make(chan string) channel同步，数据传递： 写端： ch<- “hello” ---- 写端写数据，读端不在读，阻塞 读端 ： buf ：= <-ch ---- 读端读数据，同时写端不再写，读端阻塞 len(ch) : channel中剩余未读取数据个数。cap(ch) ：通道的容量 ...
go语言无缓冲的 channel 和有缓冲的 channel 的区别
最新发布
byteinit的专栏
02-20 485
无缓冲 channel 和有缓冲 channel 是 Go 语言中两种重要的 channel 类型。它们各有优缺点，应该根据实际需求选择合适的 channel 类型。Go 语言中的 channel 是用于 goroutine 之间通信的并发原语。channel 可以是无缓冲的，也可以是有缓冲的。
超实用的 Golang 通道（channel）指南：教你轻松实现并发编程
喜欢把复杂的事情说简单
09-18 1031
Golang 中的通道是一种高效、安全、灵活的并发机制，用于在并发环境下实现数据的同步和传递。通道提供了一个线程安全的队列，只允许一个 goroutine 进行读操作，另一个 goroutine 进行写操作。通过这种方式，通道可以有效地解决并发编程中的竞态条件、锁问题等常见问题。
Golang 通道 channel
云满笔记
08-02 1706
channel
Go语言基础结构 —— Channel 通道
xjx的博客
06-25 1408
在Go语言中，channel（通道）是一种用于在goroutine之间进行通信和同步的特殊数据结构。它可以看作是一条管道，可以在不同的goroutine之间传递数据。使用通道，你可以在goroutine之间发送和接收值。通道提供了一种安全、同步的方式来共享数据。它确保在发送操作完成之前，接收操作会一直等待，并且在接收操作完成之前，发送操作也会一直等待。这种同步机制可以有效地避免并发访问共享数据时出现的竞争条件和数据竞争。Golang并发的核心哲学是不要通过共享内存进行通信。
golang如何更好地使用channel
我的天空 我的梦
05-01 599
最近学习了《GO语言并发之道》这本书，获益匪浅，其中channel方面的知识了解了更多，主要是以下几点： 1. channel在不同条件下读写，会有不同的行为形式，后面会通过实验说明； 2. channel使用完是要close的，而一般由写端创建和关闭，不要在读端关闭，上面的实验结果会说明这样做的原因； 3. channel结合gorouting有很多的实践方式，还可以构造流式处理。 先来...
Go语言并发编程——Channel
m0_62969222的博客
09-29 961
Channel是用来实现goroutine之间通信的数据类型，该类型是go自带的唯一一个处理高并发十分安全的一个类型。
golang-async-channels:提升Golang频道
05-16
我受到启发，并愿意制作类似代理或异步通道之类的东西，这些东西可以使用本机语言工具使用无限的缓冲区而无需额外的锁定。 例子 package main import ( "fmt" "time" "github....
go-advance-concurrency:收集了在Go中应用并发的最佳实践和经验教训
05-27
掌握并发并发101 更多内容。 并发是goroutine的独立执行。 函数使用关键字go作为goroutines创建。 Goroutine在拥有单个操作系统线程和运行队列的逻辑处理器的范围内执行。 竞争条件是两个或多个goroutine尝试访问...
Golang2-new.docx
02-18
个人学习golang笔记，从各种教程中总结而来，作为入门参考。目录如下 目录 1. 入门 1 1.1. Hello world 1 1.2. 命令行参数 2 2. 程序结构 3 2.1. 类型 4 2.1.1. 命名类型（named type）与未命名类型（unamed ...
gaio:用于Golang的高性能async-io（proactor）网络。 用于golang的高性能异步io（proactor）网络
04-29
盖奥 介绍 对于典型的golang网络程序，您首先要conn := lis.Accept()获取连接，然后go func(net.Conn)... 对于拥有超过10K个连接且频繁出现短消息（例如，过使用内部交换缓冲区，可以节省buf:=make([]byte,> C10K并发连
进程 线程 协程 之间的定义
weixin_30666753的博客
05-31 234
　1、进程 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位。每个进程都有自己的独立内存空间，不同进程通过进程间通信来通信。由于进程比较重量，占据独立的内存，所以上下文进程间的切换开销（栈、寄存器、虚拟内存、文件句柄等）比较大，但相对比较稳定安全。 　　2、线程 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立...
golang 学习 - chan以及chan的一下用例
tiger-guo
06-28 610
golang 学习 - chan 1. 通道 // _通道_ 是连接多个 Go 协程的管道。你可以从一个 Go 协程 // 将值发送到通道，然后在别的 Go 协程中接收。 package main import "fmt" func main() { // 使用 `make(chan val-type)` 创建一个新的通道。 // 通道类型就是他们需要传递值的类型。 messages := make(chan string) // 使用 `channel <-
golang：有缓存channel和无缓存channel的区别
OceanStar的博客
02-14 2285
goroutine 首先我们来看线程,在golang里面也叫goroutine 在读这篇文章之前，我们需要了解一下并发与并行。golang的线程是一种并发机制，而不是并行。它们之间的区别大家可以上网搜一下，网上有很多的介绍。 下面我们先来看一个例子吧 package main import( "fmt" ) func main(){ go fmt.Println("1") fmt.Pr...
重学Golang-通道使用总结
Lid_23的博客
08-19 165
通道是用来传递数据的一个数据结构，Go语言中提倡用通信的方式来替代共享内存。当一个资源需要在协程之间共享时，通道会在goroutine之间建立一个管道，并提供了确保同步交换数据的机制。go中保证了在任何时候，同时只能有一个goroutine同时访问通道进行发送和获取数据。通道属于一种队列的数据结构遵循“先进先出”的规则。需要注意的是channel的传递是传引用，在使用前需要make分配内存。如果要使用一个带缓冲的通道，需要提前设置通道的cap。
四、Golang并发编程：协程间通信与Channel
qq_43759853的博客
01-24 701
文章目录channel：定义channel：channel同步，数据传递：无缓冲channel： —— 同步通信有缓冲channel：—— 异步通信关闭channel：单向channel：生产者消费者模型：定时器：周期定时：select：select实现fibonacci数列：select 超时处理： channel： ​ 是一种数据类型。 对应一个“管道”（通道 FIFO） channel的定义： make (chan 在channel中传递的数据类型， 容量) 容量= 0： 无缓冲channel，
Golang通道的基本操作
sunriseYJP的博客
09-06 443
Golang通道的基本操作
golang sem <- struct{}{} 什么意思
06-02
例如，在使用 channel 来实现限流时，可以使用带缓冲的 channel 来限制最大并发数。在函数启动时，先向 channel 中放入一些空的结构体，代表最大并发数。之后，不断从 channel 中取出一个空结构体，表示有一个空闲的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

玄德公笔记

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值