Go channel——send/recv使用形式及场景

最新推荐文章于 2022-07-09 08:00:45 发布
最新推荐文章于 2022-07-09 08:00:45 发布
阅读量514 收藏 1
点赞数 1
分类专栏： golang 源码分析 文章标签： go channel send recv 使用场景
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xz_studying/article/details/116572843
版权

前言

channel作为通信通道，目的就是用来发送、接收消息的。在了解send、recv的具体处理之前，先看下send、recv的使用形式及场景。

更多内容分享，欢迎关注公众号：Go开发笔记

基本使用形式

  • send
ch <- 1
  • recv
x := <- ch
x,ok := <- ch

使用场景

单独使用

单独使用就是其基本使用形式。

  • send使用示例:
c <- x // send

对应底层func chansend

  • recv使用示例：

recv包含两种形式：

x = <- c 	// recv1  x可忽略
x,ok = <- c // recv2  x/ok可忽略

对应底层func chanrecv1/chanrecv2

与select搭配使用

多个send/recv操作时，则需要借助select处理。

与select搭配使用，又可以分为以下几种情况：

  • 仅有1个send/recv case

例如：

select {
case c <- v:
	... foo
}

与send/recv单独使用时一致。

  • 1个send/recv case和default case

例如：

select {
case c <- v:
	... foo
default:
	... bar
}

send对应调用的底层func为selectnbsend，recv对应调用的底层func为selectnbrecv/selectnbrecv2

与send/recv单独使用时，不同的是不会阻塞goroutine，send/recv case失败时，执行default case。

  • 多个send/recv case

此处的多个是指2个及以上。

例如：

select {
case c <- v:
	... foo
case x,ok = <-c:
    ...
default:
	... bar
}

send/recv处理逻辑交由select控制，对应底层func为selectgo，。

至于为何send/recv与select搭配使用分多种情况处理，有兴趣的话，可以看下cmd/compile/internal/gc/select.go中的源码，此处仅贴出关键源码，不再详细解释。

func walkselectcases(cases *Nodes) []*Node {
	ncas := cases.Len()
	sellineno := lineno

	// optimization: zero-case select
	if ncas == 0 {
		return []*Node{mkcall("block", nil, nil)}
	}

	// optimization: one-case select: single op.
	// 优化: 一个case的select: 单个操作
	if ncas == 1 {
		cas := cases.First()
		setlineno(cas)
		l := cas.Ninit.Slice()
		if cas.Left != nil { // not default:
			n := cas.Left
			l = append(l, n.Ninit.Slice()...)
			n.Ninit.Set(nil)
			switch n.Op {
			default:
				Fatalf("select %v", n.Op)

			case OSEND:
				// already ok

			case OSELRECV, OSELRECV2:
				if n.Op == OSELRECV || n.List.Len() == 0 {
					if n.Left == nil {
						n = n.Right
					} else {
						n.Op = OAS
					}
					break
				}

				if n.Left == nil {
					nblank = typecheck(nblank, ctxExpr|ctxAssign)
					n.Left = nblank
				}

				n.Op = OAS2
				n.List.Prepend(n.Left)
				n.Rlist.Set1(n.Right)
				n.Right = nil
				n.Left = nil
				n.SetTypecheck(0)
				n = typecheck(n, ctxStmt)
			}

			l = append(l, n)
		}

		l = append(l, cas.Nbody.Slice()...)
		l = append(l, nod(OBREAK, nil, nil))
		return l
	}

	// convert case value arguments to addresses.
	// this rewrite is used by both the general code and the next optimization.
	var dflt *Node
	for _, cas := range cases.Slice() {
		setlineno(cas)
		n := cas.Left
		if n == nil {
			dflt = cas
			continue
		}
		switch n.Op {
		case OSEND:
			n.Right = nod(OADDR, n.Right, nil)
			n.Right = typecheck(n.Right, ctxExpr)

		case OSELRECV, OSELRECV2:
			if n.Op == OSELRECV2 && n.List.Len() == 0 {
				n.Op = OSELRECV
			}

			if n.Left != nil {
				n.Left = nod(OADDR, n.Left, nil)
				n.Left = typecheck(n.Left, ctxExpr)
			}
		}
	}

	// optimization: two-case select but one is default: single non-blocking op.
	// 优化: 2个case，但是一个是default: 单个非阻塞操作
	if ncas == 2 && dflt != nil {
		cas := cases.First()
		if cas == dflt {
			cas = cases.Second()
		}

		n := cas.Left
		setlineno(n)
		r := nod(OIF, nil, nil)
		r.Ninit.Set(cas.Ninit.Slice())
		switch n.Op {
		default:
			Fatalf("select %v", n.Op)

		case OSEND:
			// if selectnbsend(c, v) { body } else { default body }
			ch := n.Left
			r.Left = mkcall1(chanfn("selectnbsend", 2, ch.Type), types.Types[TBOOL], &r.Ninit, ch, n.Right)

		case OSELRECV:
			// if selectnbrecv(&v, c) { body } else { default body }
			ch := n.Right.Left
			elem := n.Left
			if elem == nil {
				elem = nodnil()
			}
			r.Left = mkcall1(chanfn("selectnbrecv", 2, ch.Type), types.Types[TBOOL], &r.Ninit, elem, ch)

		case OSELRECV2:
			// if selectnbrecv2(&v, &received, c) { body } else { default body }
			ch := n.Right.Left
			elem := n.Left
			if elem == nil {
				elem = nodnil()
			}
			receivedp := nod(OADDR, n.List.First(), nil)
			receivedp = typecheck(receivedp, ctxExpr)
			r.Left = mkcall1(chanfn("selectnbrecv2", 2, ch.Type), types.Types[TBOOL], &r.Ninit, elem, receivedp, ch)
		}

		r.Left = typecheck(r.Left, ctxExpr)
		r.Nbody.Set(cas.Nbody.Slice())
		r.Rlist.Set(append(dflt.Ninit.Slice(), dflt.Nbody.Slice()...))
		return []*Node{r, nod(OBREAK, nil, nil)}
	}

	if dflt != nil {
		ncas--
	}
	casorder := make([]*Node, ncas)
	nsends, nrecvs := 0, 0

	var init []*Node

	// generate sel-struct
	lineno = sellineno
	selv := temp(types.NewArray(scasetype(), int64(ncas)))
	r := nod(OAS, selv, nil)
	r = typecheck(r, ctxStmt)
	init = append(init, r)

	// No initialization for order; runtime.selectgo is responsible for that.
	order := temp(types.NewArray(types.Types[TUINT16], 2*int64(ncas)))

	var pc0, pcs *Node
	if flag_race {
		pcs = temp(types.NewArray(types.Types[TUINTPTR], int64(ncas)))
		pc0 = typecheck(nod(OADDR, nod(OINDEX, pcs, nodintconst(0)), nil), ctxExpr)
	} else {
		pc0 = nodnil()
	}

	// register cases
	for _, cas := range cases.Slice() {
		setlineno(cas)

		init = append(init, cas.Ninit.Slice()...)
		cas.Ninit.Set(nil)

		n := cas.Left
		if n == nil { // default:
			continue
		}

		var i int
		var c, elem *Node
		switch n.Op {
		default:
			Fatalf("select %v", n.Op)
		case OSEND:
			i = nsends
			nsends++
			c = n.Left
			elem = n.Right
		case OSELRECV, OSELRECV2:
			nrecvs++
			i = ncas - nrecvs
			c = n.Right.Left
			elem = n.Left
		}

		casorder[i] = cas

		setField := func(f string, val *Node) {
			r := nod(OAS, nodSym(ODOT, nod(OINDEX, selv, nodintconst(int64(i))), lookup(f)), val)
			r = typecheck(r, ctxStmt)
			init = append(init, r)
		}

		c = convnop(c, types.Types[TUNSAFEPTR])
		setField("c", c)
		if elem != nil {
			elem = convnop(elem, types.Types[TUNSAFEPTR])
			setField("elem", elem)
		}

		// TODO(mdempsky): There should be a cleaner way to
		// handle this.
		if flag_race {
			r = mkcall("selectsetpc", nil, nil, nod(OADDR, nod(OINDEX, pcs, nodintconst(int64(i))), nil))
			init = append(init, r)
		}
	}
	if nsends+nrecvs != ncas {
		Fatalf("walkselectcases: miscount: %v + %v != %v", nsends, nrecvs, ncas)
	}

	// run the select
	// 其他情况执行selectgo
	lineno = sellineno
	chosen := temp(types.Types[TINT])
	recvOK := temp(types.Types[TBOOL])
	r = nod(OAS2, nil, nil)
	r.List.Set2(chosen, recvOK)
	fn := syslook("selectgo") 
	r.Rlist.Set1(mkcall1(fn, fn.Type.Results(), nil, bytePtrToIndex(selv, 0), bytePtrToIndex(order, 0), pc0, nodintconst(int64(nsends)), nodintconst(int64(nrecvs)), nodbool(dflt == nil)))
	r = typecheck(r, ctxStmt)
	init = append(init, r)

	// selv and order are no longer alive after selectgo.
	init = append(init, nod(OVARKILL, selv, nil))
	init = append(init, nod(OVARKILL, order, nil))
	if flag_race {
		init = append(init, nod(OVARKILL, pcs, nil))
	}

	// dispatch cases
	dispatch := func(cond, cas *Node) {
		cond = typecheck(cond, ctxExpr)
		cond = defaultlit(cond, nil)

		r := nod(OIF, cond, nil)

		if n := cas.Left; n != nil && n.Op == OSELRECV2 {
			x := nod(OAS, n.List.First(), recvOK)
			x = typecheck(x, ctxStmt)
			r.Nbody.Append(x)
		}

		r.Nbody.AppendNodes(&cas.Nbody)
		r.Nbody.Append(nod(OBREAK, nil, nil))
		init = append(init, r)
	}

	if dflt != nil {
		setlineno(dflt)
		dispatch(nod(OLT, chosen, nodintconst(0)), dflt)
	}
	for i, cas := range casorder {
		setlineno(cas)
		dispatch(nod(OEQ, chosen, nodintconst(int64(i))), cas)
	}

	return init
}
yuchenfw
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
socket_recv函数使用心得.
10-10
这是一份关于 socket_recv的文档，相信对想学习 socket_recv的同学一定有很大的帮助！
Go语言规格说明书 之 通道 发送语句（send） 和 接收操作符（receive）
aimianwo1708的博客
09-20 644
go version go1.11 windows/amd64 本文为阅读Go语言中文官网的规则说明书（https://golang.google.cn/ref/spec）而做的笔记，介绍Go语言的 通道 发送语句（send） 和 接收操作符（receive）。 通道主要用于协程间通信，于是，就有发送、接收操作。在Go语言规格说明书中，发送 是语句，接收是表达式...
2020-10-24：go中channel的recv流程是什么？
福大大架构师每日一题
10-24 4635
福哥答案2020-10-24： 评论
关于Go语言中的函数方法
面向生活编程
02-13 576
关于Go语言中的函数方法方法是什么函数和方法的区别Go中的“多态” 方法是什么 func (recv receiver_type) methodName(parameter_list) (return_value_list) { … } 在 Go 语言中，结构体就像是类的一种简化形式，那么面向对象程序员可能会问：类的方法在哪里呢？ 在 Go 中有一个概念，它和方法有着同样的名字，并且大体上意思相同：Go 方法是作用在接收者（receiver）上的一个函数，接收者是某种类型的变量。因此方法是一种特殊类型的函数
Go channel——block为true时chansend/chanrecv的处理机制
yuchenfw的博客
05-16 633
前言 上篇文章提到channel send/recv使用形式及场景，其中 select单个send/recv case与send/recv单独使用时一致，因此本篇先从这些简单场景出发关注send、recv的具体处理。 更多内容分享，欢迎关注公众号：Go开发笔记 send 单独使用 c <- x select单个send case select { case c <- x : } 以上两种场景send处理方式一致，底层对应func为chansend1。 chansend1具体实现
Socket-send-and-recv-.rar_c socket send recv_socket
最新发布
09-21
本文将深入探讨"Socket下send和recv使用的说明及介绍"这一主题，帮助开发者更好地理解和运用这两个关键函数。 Socket API提供了send和recv函数，它们是TCP/IP通信的核心组件，用于在套接字之间发送和接收数据。在...
send-recv-init
12-09
本文将深入探讨`send`和`recv`的工作原理、使用方法以及它们在实际应用中的重要性。 `send`函数用于向连接的套接字发送数据。其原型如下： ```c ssize_t send(int socket, const void *buf, size_t len, int flags...
对send(),recv()函数的全面理解
01-10
int send( SOCKET s, const char FAR *buf, int len, int flags ); 不论是客户还是服务器应用程序都用send函数来向TCP连接的另一端发送数据。 客户程序一般用send函数向服务器发送请求，而服务器则通常用send函数来...
UDP_send_recv.zip_UDP Send Recv_UDP协议 send_UDP接收_independent14v_
09-20
在本项目"UDP_send_recv.zip"中，我们将探讨如何使用UDP协议进行数据的发送和接收。 首先，我们有两个主要的脚本：`UDP_recv.py`和`UDP_send.py`，分别代表UDP服务器端和客户端的实现。 1. **UDP服务器端（UDP_...
深入理解Golang之Context
kevin_tech的博客，微信搜「网管叨bi叨」
03-01 1050
前言这篇文章将介绍Golang并发编程中常用到一种编程模式：context。本文将从为什么需要context出发，深入了解context的实现原理，以及了解如何使用context。为什么...
Go Channel 详解
淡淡忧桑
10-27 7881
Go Channel 详解
2020-10-21：go中channel的send流程是什么？
福大大架构师每日一题
10-21 5678
福哥答案2020-10-21： 评论
go简易tcp socket客户端和服务器
热门推荐
绯浅yousa的笔记
04-02 1万+
go简易tcp socket客户端和服务器1.Socket编程以前使用Socket编程时，一般是如下步骤 建立socket，socket 绑定socket，bind 监听，listen 接受连接，accept 接受/发送，recv/send go tcp版真的很省事 服务端： 就是Listen、Accept、Read/Write 客户端 就是Dial、Read/Write直接上代码2.Ser
Go channel 实现原理分析
无风的雨
05-14 8909
前言 channel一个类型管道，通过它可以在goroutine之间发送和接收消息。它是Golang在语言层面提供的goroutine间的通信方式。 众所周知，Go依赖于称为CSP（Communicating Sequential Processes）的并发模型，通过Channel实现这种同步模式。Go并发的核心哲学是不要通过共享内存进行通信; 相反，通过沟通分享记忆。 下面以简单的示例来演示Go...
【go源码分析】go源码之channel源码分析
zhonglinzhang
11-11 4104
源码路径runtime/chan.go CSP 模型 CSP 模型全称为 communicating sequential processes，CSP 模型由并发执行实体(进程，线程或协程)，和消息通道组成，实体之间通过消息通道发送消息 channel读写 ch := make(chan int) // write ch &lt;- x // read x &lt;- ch...
深入解读Golang信道
qq_30236895的博客
07-09 436
信道是一个golang goroutine之间很关键的通信媒介。理解golang的信道很重要，这里记录平时易忘记的、易混淆的点。1. 基本使用刚声明的信道，零值为nil，无法直接使用，需配合make函数进行初始化ic:=make(chanint) ic<-22//向无缓冲信道写入数据 v:=<-ic//从无缓冲信道读取...
Golang高级编程: 并发篇 (一) 通道 + 通道超时
听我一言的博客
07-04 1113
var chn = make(chan int, 0) var tm = time.Duration(10 * time.Second) select { case chn<-1: fmt.Println("Writed...") case <-time.After(tm): fmt.Println("Time out") }
Go Channel的基本使用及底层原理详解
爱意时刻减淡，玫瑰不再浪漫
04-22 6056
前言 如果说 goroutine 是Go程序并发的执行体，channel就是它们之间的连接。 Go语言采用的并发模型是CSP，提倡通过通信共享内存而不是通过共享内存而实现通信。channel是可以让一个 goroutine 发送特定值到另一个 goroutine 的通信机制。 1.channel类型 channel类型：未初始化的通道类型变量默认零值为nil var 变量名称 chan 元素类型 // 例如 var ch1 chan int // 声明一个传递整型的通道 var ch2 chan b
TensorFlow分布式通信机制解析：Send/Recv与RpcRemoteRendezvous
本文主要探讨了TensorFlow分布式环境中的通信机制，特别是在处理跨设备数据依赖时如何通过Send/Recv节点实现数据交换。核心是Rendezvous机制，它是TensorFlow内部数据交换的关键组成部分。 1. 机制 1.1 消息标识符...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值