golang 源码分析之select

最新推荐文章于 2023-06-28 13:18:23 发布
最新推荐文章于 2023-06-28 13:18:23 发布
阅读量268 收藏
点赞数
分类专栏： go源码分析 Go随笔 文章标签： go golang 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CrazyJ4/article/details/109726403
版权
select
让 Goroutine 同时等待多个 Channel 的可读或者可写.
在多个文件或者 Channel 发生状态改变之前，select 会一直阻塞当前线程或者 Goroutine。
select 是一种与 switch 相似的控制结构。
select 中虽然也有多个 case，但是这些 case 中的表达式必须都是 Channel 的收发操作。

scase：runtime.scase(select 控制结构中的 case )

type scase struct {
	c           *hchan         // 没有case都会和channal 有关系，所以包含一个channal的地址
	elem        unsafe.Pointer // 接收或者发送数据的变量地址
	kind        uint16         // scase 的种类
	pc          uintptr // race pc (for race detector / msan)
	releasetime int64
}
// 种类
const (
	caseNil = iota
	caseRecv
	caseSend
	caseDefault
)

select语句在编译期间会根据case的数量来进行编译器的重写和优化
cmd/compile/internal/gc.walkselectcases
1、select 不存在任何的 case；
2、select 只存在一个 case； (改写成单channal阻塞)
3、select 存在两个 case，其中一个 case 是 default； (如果非default的case阻塞了，执行case)
4、select 存在多个 case

func walkselectcases(cases *Nodes) []*Node {
	n := cases.Len()
	sellineno := lineno
	// 不存在任何case 调用mkcall("block", nil, nil) 
	// 实际会调用 runtime.gopark 让当前G让出对CPU的使用权
	// 直接阻塞当前的 Goroutine，导致 Goroutine 进入无法被唤醒的永久休眠状态。
	if n == 0 {
		return []*Node{mkcall("block", nil, nil)}
	}
	//如果当前的 select 条件只包含一个 case，那么就会将 select 改写成 if 条件语句。
	// 当 case 中的 Channel 是空指针时，就会直接挂起当前 Goroutine 并永久休眠。 
	if n == 1 {
		cas := cases.First()
		setlineno(cas)
		l := cas.Ninit.Slice()
		if cas.Left != nil {
			n := cas.Left
			l = append(l, n.Ninit.Slice()...)
			n.Ninit.Set(nil)
			var ch *Node
			switch n.Op {
			default:
				Fatalf("select %v", n.Op)
			case OSEND:
				ch = n.Left
			case OSELRECV, OSELRECV2:
				ch = n.Right.Left
				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)
			}
			// 如果ch是空 ,挂起来
			// if ch == nil { block() }; n;
			a := nod(OIF, nil, nil)
			a.Left = nod(OEQ, ch, nodnil())
			var ln Nodes
			ln.Set(l)
			a.Nbody.Set1(mkcall("block", nil, &ln))
			l = ln.Slice()
			a = typecheck(a, ctxStmt)
			l = append(l, a, n)
		}
		l = append(l, cas.Nbody.Slice()...)
		l = append(l, nod(OBREAK, nil, nil))
		return l
	}

	// 通用逻辑
	for _, cas := range cases.Slice() {
		setlineno(cas)
		n := cas.Left
		if n == nil {
			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)
			}
		}
	}

	// select 存在两个 case，其中一个 case 是 default；
	if n == 2 && (cases.First().Left == nil || cases.Second().Left == nil) {
		var cas *Node
		var dflt *Node
		if cases.First().Left == nil {
			cas = cases.Second()
			dflt = cases.First()
		} else {
			dflt = cases.Second()
			cas = cases.First()
		}

		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 }
			r = nod(OIF, nil, nil)
			r.Ninit.Set(cas.Ninit.Slice())
			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 }
			r = nod(OIF, nil, nil)
			r.Ninit.Set(cas.Ninit.Slice())
			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)}
	}

	var init []*Node

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

	order := temp(types.NewArray(types.Types[TUINT16], 2*int64(n)))
	r = nod(OAS, order, nil)
	r = typecheck(r, ctxStmt)
	init = append(init, r)

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

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

		// Keep in sync with runtime/select.go.
		const (
			caseNil = iota
			caseRecv
			caseSend
			caseDefault
		)

		var c, elem *Node
		var kind int64 = caseDefault

		if n := cas.Left; n != nil {
			init = append(init, n.Ninit.Slice()...)

			switch n.Op {
			default:
				Fatalf("select %v", n.Op)
			case OSEND:
				kind = caseSend
				c = n.Left
				elem = n.Right
			case OSELRECV, OSELRECV2:
				kind = caseRecv
				c = n.Right.Left
				elem = n.Left
			}
		}

		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)
		}

		setField("kind", nodintconst(kind))
		if c != nil {
			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 instrumenting {
			r = mkcall("selectsetpc", nil, nil, bytePtrToIndex(selv, int64(i)))
			init = append(init, r)
		}
	}

	// run the select
	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), nodintconst(int64(n))))
	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))

	// dispatch cases
	for i, cas := range cases.Slice() {
		setlineno(cas)

		cond := nod(OEQ, chosen, nodintconst(int64(i)))
		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)
	}

	return init
}

select 流程

ps :参考 https://www.jianshu.com/p/17527019285e
将所有的 case 转换成包含 Channel 以及类型等信息的 runtime.scase 结构体；  
调用运行时函数 runtime.selectgo 从多个准备就绪的 Channel 中选择一个可执行的 runtime.scase 结构体；  
通过 for 循环生成一组 if 语句，在语句中判断自己是不是被选中的 case  
1. 锁定scase语句中所有的channel

2. 按照随机顺序检测scase中的channel是否ready

　　2.1 如果case可读，则读取channel中数据，解锁所有的channel，然后返回(case index)

　　2.2 如果case可写，则将数据写入channel，解锁所有的channel，然后返回(case index)

　　2.3 所有case都未ready，则解锁所有的channel，然后返回（default index）

3. 所有case都未ready，且没有default语句

　　 3.1 将当前协程加入到所有channel的等待队列

 　　3.2 当将协程转入阻塞，等待被唤醒

4. 唤醒后返回channel对应的case index

　　4.1 如果是读操作，解锁所有的channel，然后返回(case index)

　　4.2 如果是写操作，解锁所有的channel，然后返回(case index)
nevermoress
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
go 中 select 源码阅读
pythonxxoo的博客
04-16 472
Python微信订餐小程序课程视频 https://blog.csdn.net/m0_56069948/article/details/122285951 Python实战量化交易理财系统 https://blog.csdn.net/m0_56069948/article/details/122285941 深入了解下 go 中的 select 前言 1、栗子一 2、栗子二 3、栗子三 看下源码实现 1、不存在 case 2、select 中仅存在一个 case 3、select 中存在两个 c
Golang大厂面试题及知识图谱
03-23
- **select**：多通道通信的选择器，实现同步和数据交换。 - **互斥锁（Mutex）**：保护共享资源的安全访问，防止竞态条件。 3. **Go内存管理** - **垃圾回收（GC）**：理解Go的自动垃圾回收机制，以及如何避免...
源码分析-Golang Select
Coder_Joker的博客 joke a joker
09-10 201
实现原理 每个select 在编译期间会被转换成OSELECT节点,每个OSELECT节点都有对应的OCASE信息, 不同的写法,编译器会有不同的操作 select 不存在任何的 case； select 只存在一个 case； select 存在两个 case，其中一个 case 是 default； select 存在多个 case； 相关的函数在: cmd/compile/internal/gc/select.go#walkselectcases 第一种情况: select 不
golang的select实现原理剖析
weixin_30414635的博客
03-10 249
写在最前面 select为golang提供了多路IO复用机制，和其他IO复用一样，用于检测是否有读写事件是否ready。 本文将介绍一下golang的select的用法和实现原理。 实现原理 golang实现select的时候，实际上为每一个case语句定义了一个数据结构，select语句块执行的时候，实际上可以类比成对一个case数组处理的代码块（或者函数），然后程序流程转到选中的cas...
由浅入深聊聊Golang中select的实现机制
热门推荐
咖啡色的羊驼
08-31 1万+
正文 话说今天在玩select的时候发现一个问题，是这样的： 片段1： func main(){ var count int for { select { case <-time.Tick(time.Millisecond * 500): fmt.Println("咖啡色的羊驼")
go:select channel源码
stevewong的专栏
12-02 193
参考 go夜读 buffered和unbuffered buffered: ch <- v happens before v <- ch 有buffer的情况下：先把值写到channel，才能读到 make(chan interface{}, size) unbuffered: v <- ch happens before ch <- v 无buffer呢？先读了，之后才写。（没有中间人拿这个东西） make(chan interface{}, 0) Go Schedule
00-Golang教程 课件+源码 -大地老师.zip
最新发布
05-16
《Golang教程 课件+源码 -大地老师》是一个全面深入学习Go语言的资源包，包含课件和源码两个主要部分，旨在帮助初学者和有经验的开发者更好地理解和运用Go语言。以下是对这两个部分的详细解读： 一、Golang教程上课...
Go语言入门经典 源码
08-25
9. **源码分析** “golang-book-examples-master”这个目录很可能包含了一系列Go语言的示例代码，涵盖了上述知识点的实际应用，你可以通过阅读和运行这些代码来加深理解。 10. **编译与运行** - Go语言的源代码...
go/goland TCP 服务 源码.zip
06-11
6. **源码分析**： - 在提供的源码中，可能包含了TCP服务器的初始化、连接处理函数、读写数据的逻辑以及异常处理部分。通过对源码的分析，我们可以更深入理解Go语言实现TCP服务的方式。 7. **高级特性**： - Go的...
goselect:Go中的select（2）实现
05-10
去选择 Go中的select（2）实现 支持平台 386 amd64 手臂 臂64 ps 小偷 mips64 mips64le ppc64le s390x linux 是的 是的 是的 是的 是的 是的 是的 是的 是的 是的 达尔文 是的 是的 ?? ?? 不适用 不适用 不适用 不适用 不适用 不适用 freebsd 是的 是的 是的 不适用 不适用 不适用 不适用 不适用 不适用 不适用 的openbsd 是的 是的 是的 不适用 不适用 不适用 不适用 不适用 不适用 不适用 netbsd 是的 是的 是的 不适用 不适用 不适用 不适用 不适用 不适用 不适用 蜻蜓 不适用 是的 不适用 不适用 不适用 不适用 不适用 不适用 不适用 不适用 日光浴 不适用 不 不适用 不适用 不适用 不适用 不适用 不适用 不适用 不适用 计划9 不 不 不 不适
Go源码解析之select.go
techdashen的博客
06-28 115
select操作是一种用于在多个channel上等待数据的机制，而selparkcommit函数的作用就是将当前的M挂起，在等待期间由其他线程负责M的工作，当有数据可用时唤醒M并重新提交M以继续执行后续的操作。在Go语言中，select语句用于同时等待多个通道的操作。在selectgo()函数中，会使用selectsetpc()函数将下一个需要执行的case的PC值和SP值保存到当前的运行栈中，然后使用Go语言的栈切换机制，将当前的goroutine挂起，切换到下一个goroutine执行。
Golang教程：（二十四）Select
zhangbohh8662的博客
02-09 1184
原文地址：https://golangbot.com/select/欢迎来到第二十四节。什么是select?select模式是用来从多输入/输出通道中进行选择的一种操作。select模式下会一直阻塞直到至少一个可读/写操作就绪，如果多个读写操作就绪，那么久随机从中选择一个。语法有点类似switch除了每个case选择都是一个通道操作。为了更好理解上代码：package main import ...
golang 面试题（六）select
诸君拔剑吧.
05-07 749
1.下面代码会触发异常吗？请详细说明 func main() { runtime.GOMAXPROCS(1) int_chan := make(chan int, 1) string_chan := make(chan string, 1) int_chan <- 1 string_chan <- "hello" select { ...
golang中的select原理解析
猛犸象
08-08 576
golang中的select原理解析
golang channel 使用方法
浴血重生-学习空间
04-12 809
Golang Channel 1. A goroutine is a lightweight thread managed by the Go runtime. go f(x, y, z) starts a new goroutine running f(x, y, z) The evaluation of f, x, y, and z happens in the current gorou...
Golang 深入源码 —— select 与 channel
IceberGu的博客
09-03 1万+
Golang 通过 select...case 语句实现了对 channel 的多路复用以及非阻塞收发操作 本文将着重讲解以下问题： 编译器对 select 语句的优化 select 如何随机选择 case 当多个 case 同时准备好后，select 又会如何选择 case
golang 之select 的高级用法
weixin_34405332的博客
04-24 4159
select有3个特色分别是： nil的通道永远阻塞 如何跳出for -select 循环 select{} 永远阻塞 nil通道永远阻塞 当case上读取一个通道时，如果这个通道是 nil , 则该case 永远阻塞，这个特性我们可以自定义将某个信道强制进行阻塞 func CombineChannel(ch1,ch2 chan int) <-chan int { out ...
Golang select 基础语法与用法
golang 相关内容分享
11-22 411
golang select 关键字基础语法与用法
golang select
05-23
select 是 Go 语言中用于实现多路复用的语句。它可以同时监听多个通道上的数据流动，并在其中的一个通道有数据可读或可写时立即进行响应。select 语句的语法如下： ``` select { case <- channel1: // 处理 channel1 数据 case data := <- channel2: // 处理 channel2 数据 case channel3 <- data: // 写入数据到 channel3 default: // 当所有通道都无数据可读或可写时执行 } ``` select 语句会阻塞程序，直到其中一个通道有数据可读或可写，然后执行相应的操作。如果多个通道同时有数据可读或可写，select 会随机选择其中一个进行操作。default 分支是可选的，当所有通道都无数据可读或可写时会执行。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值