Go chan基础1

已于 2023-02-27 22:17:44 修改
阅读量151 收藏
点赞数
分类专栏： Go 文章标签： golang
于 2023-02-27 12:09:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42430947/article/details/129239179
版权

值表示
通道类型是一个引用类型，所以初始化前，为此类型的零值：nil。
初始化通道
缓冲通道（10）：
make（chan int，10）
make（chan int）
非缓冲通道：
make（chan int）
一个通道值的缓冲容量总是固定不变的。如果第二个参数值被省略了,就表示被初始化的这个通道永远无法缓冲任何元素值。发送给它的元素值应该被立刻取走，否则发送方的goroutine就会被暂停(或者说阻塞),直到有接收方接收这个元素值。
需要特别注意：
试图从一个未被初始化的通道值（即值为nil的通道）那里接收值，会造成当前goroutine的永久阻塞！
同样，向nil 通道 发送值，goroutine也会被永久阻塞！
操作特性
通道是在多个goroutine之间传递数据和同步数据的重要手段，而对通道的操作本身也是同步的。
在同一时刻，仅有一个goroutine能向一个通道发送值，
同时也仅有一个goroutine能接收值。
在通道中，先进先出，相当于FIFO的消息队列。
通道中的每个值都只可能被某一个goroutine接收，已接受的值会立刻从通道中删除。

Go语言中 空结构类型的变量是不占用任何内存空间的，
并且所有该类型的变量都拥有相同的内存地址。
建议用于传递"信号"的通道，都以struct{}作为元素类型，除非需要传递更多信息。

package main

import (
	"fmt"
	"time"
)

var strChan = make(chan string, 3)

func main() {

	// 通知接受操作chan
	syncChan1 := make(chan struct{}, 1)
	// 避免主goroutine过早结束
	syncChan2 := make(chan struct{}, 2)
	go func() { // 用于接收操作。
		<-syncChan1
		fmt.Println("Received a sync signal and wait a second... [receiver]")
		time.Sleep(time.Second)
		for {
			if elem, ok := <-strChan; ok {
				fmt.Println("Received:", elem, "[receiver]")
			} else {
				break
			}
		}
		fmt.Println("Stopped. [receiver]")
		syncChan2 <- struct{}{}
	}()
	go func() { // 用于发送操作。
		for _, elem := range []string{"a", "b", "c", "d"} {
			strChan <- elem
			fmt.Println("Sent:", elem, "[sender]")
			if elem == "c" {
				syncChan1 <- struct{}{}
				fmt.Println("Sent a sync signal. [sender]")
			}
		}
		fmt.Println("Wait 2 seconds... [sender]")
		time.Sleep(time.Second * 2)
		close(strChan)
		syncChan2 <- struct{}{}
	}()
	<-syncChan2
	<-syncChan2
}


//输出
Sent: a [sender]
Sent: b [sender]
Sent: c [sender]
Sent a sync signal. [sender]
Received a sync signal and wait a second... [receiver]
Received: a [receiver]
Received: b [receiver]
Received: c [receiver]
Received: d [receiver]
Sent: d [sender]
Wait 2 seconds... [sender]
Stopped. [receiver]

在这里插入图片描述

除此之外,如果有多个goroutine因向同一个已满的通道发送元素值而被阻塞,那么当该通道中有多余空间的时候,最早被阻塞的那个goroutine会最先被唤醒。对于接收操作来说，也是如此，一旦已空的通道中有了新的元素值，那么最早因从该通道接收元素值而被阻塞的那个goroutine会最先被唤醒。
并且, Go运行时系统每次只会唤醒一个goroutine。

还有一点需要注意：发送方向通道发送的值会被复制，接收方接收的总是该值的副本,而不是该值本身。经由通道传递的值至少会被复制一次,至多会被复制两次。
例如,当向一个已空的通道发送值，且已有至少一个接收方因此等待时，该通道会绕过本身的缓冲队列，直接把这个值复制给最早等待的那个接收方。
又例如，当从一个已满的通道接收值,且已有至少一个发送方因此等待时,该通道会把缓冲队列中最早进入的那个值复制给接收方,再把最早等待的发送方要发送的数据复制到那个值的原先位置上。通道的缓冲队列属于环形队列,所以这样做是没问题的。
这种情况下,涉及的那两个值在传递到接收方之前都会被复制两次。
因此，当接收方从通道接收到一个值类型的值时，对该值的修改就不会影响到发送方持有的那个源值。但对于引用类型的值来说,这种修改会同时影响收发双方持有的值。

// chanval1.go
package main

import (
	"fmt"
	"time"
)

var mapChan = make(chan map[string]int, 1)

func main() {
	syncChan := make(chan struct{}, 2)
	go func() { // 用于演示接收操作。
		for {
			if elem, ok := <-mapChan; ok {
				elem["count"]++
			} else {
				break
			}
		}
		fmt.Println("Stopped. [receiver]")
		syncChan <- struct{}{}
	}()
	go func() { // 用于演示发送操作。
		countMap := make(map[string]int)
		for i := 0; i < 5; i++ {
			mapChan <- countMap
			time.Sleep(time.Millisecond)
			fmt.Printf("The count map: %v. [sender]\n", countMap)
		}
		close(mapChan)
		syncChan <- struct{}{}
	}()
	<-syncChan
	<-syncChan
}


//输出
The count map: map[count:1]. [sender]
The count map: map[count:2]. [sender]
The count map: map[count:3]. [sender]
The count map: map[count:4]. [sender]
The count map: map[count:5]. [sender]
Stopped. [receiver]

在这里插入图片描述

chan val 值类型

// chanval2.go
package main

import (
	"fmt"
	"time"
)

// Counter 代表计数器的类型。
type Counter struct {
	count int
}

// 引用类型，其值类型属性不会被修改
var mapChan = make(chan map[string]Counter, 1)
//var mapChan = make(chan map[string]*Counter, 1)

func main() {
	syncChan := make(chan struct{}, 2)
	go func() { // 用于演示接收操作。
		for {
			if elem, ok := <-mapChan; ok {
				counter := elem["count"]
				counter.count++
			} else {
				break
			}
		}
		fmt.Println("Stopped. [receiver]")
		syncChan <- struct{}{}
	}()
	go func() { // 用于演示发送操作。
		countMap := map[string]Counter{
			"count": Counter{},
		}
		//countMap := map[string]*Counter{
		//	"count": &Counter{},
		//}
		for i := 0; i < 5; i++ {
			mapChan <- countMap
			time.Sleep(time.Millisecond)
			fmt.Printf("The count map: %v. [sender]\n", countMap)
		}
		close(mapChan)
		syncChan <- struct{}{}
	}()
	<-syncChan
	<-syncChan
}


//输出
The count map: map[count:{0}]. [sender]
The count map: map[count:{0}]. [sender]
The count map: map[count:{0}]. [sender]
The count map: map[count:{0}]. [sender]
The count map: map[count:{0}]. [sender]
Stopped. [receiver]

chan val 引用类型

package main

import (
	"fmt"
	"time"
)

// Counter 代表计数器的类型。
type Counter struct {
	count int
}

//var mapChan = make(chan map[string]Counter, 1)
// 指针引用类型的指针类型，其值类型属性 会被修改
var mapChan = make(chan map[string]*Counter, 1)

func main() {
	syncChan := make(chan struct{}, 2)
	go func() { // 用于演示接收操作。
		for {
			if elem, ok := <-mapChan; ok {
				counter := elem["count"]
				counter.count++
			} else {
				break
			}
		}
		fmt.Println("Stopped. [receiver]")
		syncChan <- struct{}{}
	}()
	go func() { // 用于演示发送操作。
		//countMap := map[string]Counter{
		//	"count": Counter{},
		//}
		countMap := map[string]*Counter{
			"count": &Counter{},
		}
		for i := 0; i < 5; i++ {
			mapChan <- countMap
			time.Sleep(time.Millisecond)
			fmt.Printf("The count map: %v. [sender]\n", countMap)
		}
		close(mapChan)
		syncChan <- struct{}{}
	}()
	<-syncChan
	<-syncChan
}


The count map: map[count:0xc00001a078]. [sender]
The count map: map[count:0xc00001a078]. [sender]
The count map: map[count:0xc00001a078]. [sender]
The count map: map[count:0xc00001a078]. [sender]
The count map: map[count:0xc00001a078]. [sender]
Stopped. [receiver]

关闭通道

package main

import "fmt"

func main() {
	dataChan := make(chan int, 5)
	syncChan1 := make(chan struct{}, 1)
	syncChan2 := make(chan struct{}, 2)
	go func() { // 用于演示接收操作。
		<-syncChan1
		for {
			if elem, ok := <-dataChan; ok {
				fmt.Printf("Received: %d [receiver]\n", elem)
			} else {
				break
			}
		}
		fmt.Println("Done. [receiver]")
		syncChan2 <- struct{}{}
	}()
	go func() { // 用于演示发送操作。
		for i := 0; i < 5; i++ {
			dataChan <- i
			fmt.Printf("Sent: %d [sender]\n", i)
		}
		close(dataChan)
		syncChan1 <- struct{}{}
		fmt.Println("Done. [sender]")
		syncChan2 <- struct{}{}
	}()
	<-syncChan2
	<-syncChan2
}

在这里插入图片描述

星星点点洲
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
golang判断chan channel是否关闭的方法
09-21
主要介绍了golang判断chan channel是否关闭的方法,结合实例形式对比分析了Go语言判断chan没有关闭的后果及关闭的方法,需要的朋友可以参考下
go chan简单使用
python基础
03-01 9217
chan在go中是一个通道有可读可写的chan,也存在只读只写的chan,通过共享内存而实现通信 chan 注意点： 在关闭chan后再关闭chan 会出现panic 关闭chan后可以继续进行取值，取完后可以再取但都是对应类型的0值。 可以通过 v,ok:=<-ch 来判断是否取完了 取完了ok为false 也可以通过for range 来取值 for v：= range ch{ fmt.Printf("the data is %d",v) } for { v,ok:=<-ch i
【Go语言】深入浅出chan（各种实例场景+分析）
weixin_44938441的博客
12-26 2886
文章目录chan简介问题引入有缓冲通道 chan简介 chan 是go的一个关键字，也就是通道的意思，通道是goroutine之间通信和同步的重要组件，也就是go通过通信来共享内存的猜题 问题引入 先引出一个问题来加深理解： 求1-200每个数的阶乘，要求开启200个goroutine各自执行，并将结果存入同一map中，等全部存入完毕后再遍历 直接定义好map后启动goroutine来操作： var ( maps = make(map[int]int,10) ) func main(){ for
Go chan的底层原理
weixin_45743893的博客
02-14 1196
Go chan的底层原理 什么是channel？ chan是Go中的一种特殊类型，不同的协程可以通过channel来进行数据交互。 channel分为有缓冲区与无缓冲区两种。 如果当前协程向无缓冲区chan发送一条消息，但是这个chan没有就绪的接收协程时，当前协程就会被阻塞，直到出现一个接收者协程就绪，并从chan中接收这条消息。 channel的底层实现 channel是基于环形队列实现的。 type hchan struct { qcount uint // 当前队列中剩余元素个
Go chan实现并发请求聚合功能
piaohai的专栏
03-06 755
背景 有上万台边缘机器，每台都会有多个agent客户端，并且每个agent都会同时向中心系统上报数据，由于上报数据频繁，并发量也大，每个agent都频繁和中心建立连接，导致中心压力非常大，所以需要对此进行优化，对每台机器上的agent上报数据做聚合，批量进行上报，减少边缘和中心的上报频率，从而减轻中心压力。 方案 边缘增加一个batch中间件，所有agent上报的数据由原来直接向中心上报变为向batch中间件上报 batch中间件会聚合请求，再分批向中心上报 上报的方式也由原来的同步也改为异步，agent
GO语言中chan的理解
蓝易云
08-16 228
在Go语言中，chan是一种用于在并发编程中进行通信的关键字。它代表了一个通道（channel），可以在不同的goroutine之间传递数据。通过通道，可以在不同的goroutine之间安全地传递数据，实现协程间的同步和协作。通道的发送和接收操作具有阻塞特性，使得并发编程更加简单和可靠。通道提供了同步的特性，当发送操作和接收操作在不同的goroutine中进行时，它们会自动阻塞，直到另一方准备好。通道还可以具有容量，通过在创建通道时指定容量来实现。具有容量的通道可以存储多个元素，而不仅仅是单个元素。
GO 中 Chan 实现原理分享
最新发布
01-29
本文聚焦： 1.chan是什么 2.chan的底层数据结构 3.chan的读写基本流程 4.与sync的区别
详解go语言 make(chan int, 1) 和 make (chan int) 的区别
12-23
遇到golang channel 的一个问题：发现go 协程读取channel 数据 并没有按照预期进行协作执行。 经过查资料： 使用channel 操作不当导致,channel分 有缓冲区 和 无缓冲区 , 以下是两者的区别。 无缓冲区channel 用...
理解golang中关键字-chan&select
01-08
chan channel直译过来就是管道，chan关键字定义了goroutine中的管道通信，一个goroutine可以和另一个...- 1; ch <- 2; //read data from chan var x int; x = <-ch; x = <-ch; 看下面这段代码，其中x获
GO 中 Chan 实现原理
FeelTouch Labs
11-10 225
tag说明qcount当前的队列，剩余元素个数dataqsiz环形队列可以存放的元素个数，也就是环形队列的长度buf指针，指向环形队列elemsize指的的队列中每个元素的大小closed具体标识关闭的状态elemtype见名知意，元素的类型sendx发送队列的下标，向队列中写入数据的时候，存放在队列中的位置recvx接受队列的下标，从队列的 这个位置开始读取数据recvq协程队列，等待读取消息的协程队列sendq协程队列，等待发送消息的协程队列lock互斥锁，在 chan 中，不可以并发的读写数据。
chan：Go频道的纯C实现
01-31
chan：Go频道的纯C实现
gochan：用Go编写的半独立式图像板服务器
02-05
高尚 用Go编写的半独立图像板服务器 Gochan的工作方式类似于Kusaba X，Tinyboard等。 这样，Gochan会生成静态HTML文件，可以选择由单独的Web服务器提供该文件。 演示安装： ： 安装 基本安装（从发行版开始） 将.tar.gz或.zip文件解压缩到目录（例如，您的主目录）中 将gochan.example.json复制到gochan.json或（如果您使用的是类似UNIX的操作系统）/etc/gochan/gochan.json并根据需要进行修改。 有关更多信息，请参见“配置”部分。 如果您使用的是nginx，请复制gochan-http.nginx或g
go中的chan
weixin_44913757的博客
08-14 539
go语言中的channel：提供goroutine之间的通信
go chan 类型用法
u011714033的博客
05-10 3947
引用类型 零值 nil <发送/写>型 chan<- <接收/读>型 <-chan 双向型 chan 构造/初始化 make() 关闭 close() 可作左值 判等 == <发送/写>数据 chan <- send_date <接受/读>数据 recv_data := <- chan chan 关闭或有数据,读操作不阻塞 ...
go语言使用chan的小技巧
papaya的博客
08-06 303
go语言chan的使用技巧
Go channel的使用场景,用法总结
Mark66890620
04-06 1955
在介绍10种操作前，先简要介绍下channel的使用场景、基本操作和注意事项。 channel的使用场景 把channel用在数据流动的地方： 消息传递、消息过滤 信号广播 事件订阅与广播 请求、响应转发 任务分发 结果汇总 并发控制 同步与异步 ... channel的基本操作和注意事项 channel存在3种状态： nil，未初始化的状态，只进行了声明，或者手动赋值为nil active，正常的channel，可读或者可写 closed，已关闭，千万不要误认为关闭chann
Go语言通过chan进行数据传递
YIYIYI
06-12 1671
Go语言通过chan进行数据传递
go-chan例子及理解
junjiahuang的博客
08-16 434
代码】go-chan例子及理解。
golang chan
10-12
golang中的chan是一种并发通信的机制，用于在不同的goroutine之间传递数据。chan可以是带缓冲的或者非缓冲的，非缓冲的chan在发送和接收数据时会阻塞，直到有另一个goroutine接收或发送数据。而带缓冲的chan则可以在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值