源码分析-Golang Chan

channel结构体

• src/runtime/chan.go

• 内部存储是以循环队列的形式存储额

• type hchan struct {
  	qcount   uint           // 代表着这队列中总共有多少元素
  	dataqsiz uint           // 创建时的容量设置,既make时候的大小,
  	buf      unsafe.Pointer // 存储的数据
  	elemsize uint16 // chan数据对象的自身大小,既make的时候的参数类型的大小
  	closed   uint32  // 标识关闭状态
  	elemtype *_type // 代表chan中的元素类型
  	sendx    uint   // 待发送的索引,既循环队列的队尾指针tail
  	recvx    uint   // 待读取的索引,既循环队列的队头head
  	recvq    waitq  // 接收方 的等待队列
  	sendq    waitq  // 发送方 的等待队列
  	lock mutex
  }
  

channel的创建

• 相关常量定义

  • const (
    	maxAlign  = 8
    	hchanSize = unsafe.Sizeof(hchan{}) + uintptr(-int(unsafe.Sizeof(hchan{}))&(maxAlign-1))
    	debugChan = false
    )
    

    • maxAlign: 这个与操作系统有关,cpu有三级缓存,L1,L2,L3,L3cpu之间共享,数据以cacheline的形式存储在寄存器中,读取的时候,会通过总线广播其他cpu,标识cache line 无效, 如果cache line 中存储的不是同一种数据,会使得触发伪共享问题,而maxAlign就是为了使得,该数据刚好占满整个cache line (空间换时间的做法)
    • hchansize: 与Java的hashMap类似,都是为了使得cap 为2的n次方

• chan分为: 无缓冲chan和有缓存chan

  • 无缓冲既: make(chan int) : 这时候可以认为只是用于 通知
  • 有缓冲: make(chan int,10) : 可以用于数据传输

• 源码分析

  • func makechan(t *chantype, size int) *hchan {
    	// 获取元素
    	elem := t.elem 
    
    	// 获取make的元素的所占内存大小,可以发现对象的大小是有限定
    	if elem.size >= 1<<16 {
    		throw("makechan: invalid channel element type")
    	}
    	// 不同的操作系统cacheline的大小是不同的,但是都是2的n次方
    	if hchanSize%maxAlign != 0 || elem.align > maxAlign {
    		throw("makechan: bad alignment")
    	}
    	// 当乘积过大,超出内存时候,panic
    	mem, overflow := math.MulUintptr(elem.size, uintptr(size))
    	if overflow || mem > maxAlloc-hchanSize || size < 0 {
    		panic(plainError("makechan: size out of range"))
    	}
    
    	// 注意: 当如果创建的对象不是指针的话,gc不会对该部分进行检测回收
    	var c *hchan
    	switch {
    	case mem == 0:
    		// 创建的是,无缓冲通道
    		// 申请内存空间,可以发现,当为无缓冲的通道的时候,创建的是空值
    		c = (*hchan)(mallocgc(hchanSize, nil, true))
    
    		c.buf = c.raceaddr()
    	case elem.ptrdata == 0:
    		// 如果 chan的数据非指针对象,则一次创建全部: 
    		c = (*hchan)(mallocgc(hchanSize+mem, nil, true))
    		c.buf = add(unsafe.Pointer(c), hchanSize)
    	default:
    		// 当包含指针时,2次创建
    		c = new(hchan)
    		c.buf = mallocgc(mem, elem, true)
    	}
    
    	c.elemsize = uint16(elem.size)
    	c.elemtype = elem
    	c.dataqsiz = uint(size)
    	lockInit(&c.lock, lockRankHchan)
    
    	if debugChan {
    		print("makechan: chan=", c, "; elemsize=", elem.size, "; dataqsiz=", size, "\n")
    	}
    	return c
    }
    

chan的发送

• func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
  // 如果为空,且阻塞,直接挂起该goroutine跑出异常
  	if c == nil {
  		if !block {
  			return false
  		}
  		gopark(nil, nil, waitReasonChanSendNilChan, traceEvGoStop, 2)
  		throw("unreachable")
  	}
  
  	.... 省略一些debug 
  
  	// 写数据的时候是必须要加锁的,但是加锁的性能损耗大,所以加锁前会先提前判断是否可以退出
  	// 当非阻塞写 + 未关闭+ 如果数据满了
  	if !block && c.closed == 0 && full(c) {
  		return false
  	}
  
  	var t0 int64
  	if blockprofilerate > 0 {
  		t0 = cputicks()
  	}
  	
  	// 开始加锁
  	lock(&c.lock)
  	
  	// 安全性校验
  	if c.closed != 0 {
  		unlock(&c.lock)
  		panic(plainError("send on closed channel"))
  	}
  	// 如果当前等待队列中有在等待的,则会直接将该数据dropoff给这个receiver,不将数据保存到buf中
  	if sg := c.recvq.dequeue(); sg != nil {
  		send(c, sg, ep, func() { unlock(&c.lock) }, 3)
  		return true
  	}
  	
  	// 如果还有空间剩余
  	if c.qcount < c.dataqsiz {
  		qp := chanbuf(c, c.sendx)
  		if raceenabled {
  			racenotify(c, c.sendx, nil)
  		}
  		// 将该实例数据拷贝buf中
  		typedmemmove(c.elemtype, qp, ep)
  		// 然后更新索引,环形数组的话,下次还会从0开始
  		c.sendx++
  		if c.sendx == c.dataqsiz {
  			c.sendx = 0
  		}
  		// 更新拥有的数据数量
  		c.qcount++
  		unlock(&c.lock)
  		return true
  	}
  	// 进入这,说明没有空间剩余了,如果非阻塞,则直接return(既select-default的做法)
  	if !block {
  		unlock(&c.lock)
  		return false
  	}
  
  	
  	// 开始挂起,获取当前的goroutine
  	gp := getg()
  	// 获取sudog ,打包当前对象,并且与当前的g所绑定
  	mysg := acquireSudog()
  	mysg.releasetime = 0
  	if t0 != 0 {
  		mysg.releasetime = -1
  	}
  	mysg.elem = ep
  	mysg.waitlink = nil
  	mysg.g = gp
  	mysg.isSelect = false
  	mysg.c = c
  	gp.waiting = mysg
  	gp.param = nil
  	// 更新sudog到发送的等待队列中
  	c.sendq.enqueue(mysg)
  	// 调用gopark 进行阻塞
  	atomic.Store8(&gp.parkingOnChan, 1)
  	gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanSend, traceEvGoBlockSend, 2)
  
  	KeepAlive(ep)
  
   // 被唤醒之后,先进行安全性校验,如果当前的sudog与设置的不符合,则认为是数据被破坏了
  	if mysg != gp.waiting {
  		throw("G waiting list is corrupted")
  	}
  	gp.waiting = nil
  	gp.activeStackChans = false
  	closed := !mysg.success
  	gp.param = nil
  	if mysg.releasetime > 0 {
  		blockevent(mysg.releasetime-t0, 2)
  	}
  	mysg.c = nil
  	// 然后开始释放
  	releaseSudog(mysg)
  	if closed {
  		if c.closed == 0 {
  			throw("chansend: spurious wakeup")
  		}
  		panic(plainError("send on closed channel"))
  	}
  	return true
  }
  

• func send(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
  	// 如果接收方是有实例数据等待接收
  	if sg.elem != nil {
  	// 则直接将数据拷贝到receiver的接收数据结构中
  		sendDirect(c.elemtype, sg, ep)
  		sg.elem = nil
  	}
  	gp := sg.g
  	unlockf()
  	gp.param = unsafe.Pointer(sg)
  	sg.success = true
  	if sg.releasetime != 0 {
  		sg.releasetime = cputicks()
  	}
  	// 最后唤醒接收方goroutine
  	goready(gp, skip+1)
  }
  

channel的接收

• // 第一个参数是chan的指针, 第二个参数是
  func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
  	// 与send的时候同理,对于nil channel直接挂起
  
  	// 同样,与send 同理,会有fastFail 校验,来避免加锁
  	if !block && empty(c) {
  
  		if atomic.Load(&c.closed) == 0 {
  			return
  		}
  		if empty(c) {
  			if raceenabled {
  				raceacquire(c.raceaddr())
  			}
  			if ep != nil {
  				typedmemclr(c.elemtype, ep)
  			}
  			return true, false
  		}
  	}
  
  	var t0 int64
  	if blockprofilerate > 0 {
  		t0 = cputicks()
  	}
  	// 加锁
  	lock(&c.lock)
  	// 如果chan已经close了,并且没有任何数据
  	if c.closed != 0 && c.qcount == 0 {
  		if raceenabled {
  			raceacquire(c.raceaddr())
  		}
  		// 则直接解锁,然后
  		unlock(&c.lock)
  		if ep != nil {
  			// 将返回值置为0值
  			typedmemclr(c.elemtype, ep)
  		}
  		return true, false
  	}
  	// 如果有sender 阻塞,则直接pop出第一个,直接从发送方获取数据
  	if sg := c.sendq.dequeue(); sg != nil {
  		recv(c, sg, ep, func() { unlock(&c.lock) }, 3)
  		return true, true
  	}
  	
  	// 没有sender在发送数据,同时缓冲中有数据,则直接从缓冲中读取数据
  	if c.qcount > 0 {
  
  		// 则通过recvindex 得到数据
  		qp := chanbuf(c, c.recvx)
  		if raceenabled {
  			racenotify(c, c.recvx, nil)
  		}
  		// 然后将数据内容拷贝到参数中
  		if ep != nil {
  			typedmemmove(c.elemtype, ep, qp)
  		}
  		typedmemclr(c.elemtype, qp)
  		c.recvx++
  		if c.recvx == c.dataqsiz {
  			c.recvx = 0
  		}
  		c.qcount--
  		unlock(&c.lock)
  		return true, true
  	}
  	// 没数据,且异步,则直接返回
  	if !block {
  		unlock(&c.lock)
  		return false, false
  	}
  	// 说明什么数据也没有,开始挂起该goroutine
  	gp := getg()
  	// 获取sudog,打包成sudog,将sudog 与当前goroutine绑定
  	mysg := acquireSudog()
  	mysg.releasetime = 0
  	if t0 != 0 {
  		mysg.releasetime = -1
  	}
  	
  	mysg.elem = ep
  	mysg.waitlink = nil
  	gp.waiting = mysg
  	mysg.g = gp
  	mysg.isSelect = false
  	mysg.c = c
  	gp.param = nil
  	// 将该recv的goroutine入队
  	c.recvq.enqueue(mysg)
  
  	atomic.Store8(&gp.parkingOnChan, 1)
  	gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanReceive, traceEvGoBlockRecv, 2)
  
  	// 安全性检测
  	if mysg != gp.waiting {
  		throw("G waiting list is corrupted")
  	}
  
  	gp.waiting = nil
  	gp.activeStackChans = false
  	if mysg.releasetime > 0 {
  		blockevent(mysg.releasetime-t0, 2)
  	}
  	success := mysg.success
  	gp.param = nil
  	mysg.c = nil
  	releaseSudog(mysg)
  	return true, success
  }
  

• 如果有sender 在等待队列中等待,则直接从sender中拿去数据
  func recv(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
  	// 如果是无缓冲的chan
  	if c.dataqsiz == 0 {
  		if raceenabled {
  			racesync(c, sg)
  		}
  		if ep != nil {
  			// 从直接从sender的sudog 中提取数据
  			recvDirect(c.elemtype, sg, ep)
  		}
  	} else {
  		进入到这里,说明缓冲是满的
  		1. 从缓冲中拿去数据
  		2. 更新recvIndex
  		3. 更新sendIndex
  		qp := chanbuf(c, c.recvx)
  		if raceenabled {
  			racenotify(c, c.recvx, nil)
  			racenotify(c, c.recvx, sg)
  		}
  		// copy data from queue to receiver
  		if ep != nil {
  			typedmemmove(c.elemtype, ep, qp)
  		}
  		// copy data from sender to queue
  		typedmemmove(c.elemtype, qp, sg.elem)
  		c.recvx++
  		if c.recvx == c.dataqsiz {
  			c.recvx = 0
  		}
  		c.sendx = c.recvx // c.sendx = (c.sendx+1) % c.dataqsiz
  	}
  	sg.elem = nil  // 可以认为是快速清除引用 
  	gp := sg.g 
  	unlockf()
  	gp.param = unsafe.Pointer(sg)
  	// 然后跟新sender 中的sudog 为success
  	sg.success = true
  	if sg.releasetime != 0 {
  		sg.releasetime = cputicks()
  	}
  	// 通知sender ,唤醒sender
  	goready(gp, skip+1)
  }
  

总结

• 数据通信不是通过共享内存的形式来通信,而是通过 copy 内存的形式,既发送和接收得到数据都会触发拷贝操作

• golang的hchan,内部是回环数组实现数据的存储

• 对于nilchannel 会触发挂起

• 无论是send还是recv,当都会有一个快速失败的校验,因为数据写入和读取都是需要加锁的

• 无论是send还是recv,都会先判断是否 recv队列和send队列是否为空,不为空的话

  • 对于recv而言,则会先直接从发送队列中取出sudog,然后从环形队列中取出值给recv之后,将发送队列的sudog的值追加到环形队列中
  • 对于send而言,则直接从recv队列中拿出sudog,然后把要发送的数据直接转交给这个receiver
  • 最后,都会唤醒从队列取出的sudog所绑定的goroutine

问题

• chan无缓冲和有缓冲的区别

  • 无缓冲的话,初始化make的时候,申请内存的时候是一个空值
  • 无缓冲的chan,读写必须在不同的routine

• 当chan为无缓冲的时候,send和recv会做什么

  • send和recv 必须是 不在同一个routine才行

• recv的时候什么情况下,参数会为空

  • 当 <-c 的时候,参数是空参数

• closed := !mysg.success 的触发情况有哪些

  • 当close的时候,close的时候会将等待队列中所有的succes都设置为false

• send 什么时候被唤醒,是怎么被唤醒的

  • when: 如果buffer满的时候,send的goroutine会被打包成sudog,然后丢入到发送队列中,等待被唤醒
  • how: 通过goready 被唤醒,当recv的时候,如果有send在等待,则会将数据从缓冲数据取出来之后,唤醒等待队列中的头节点

• 什么是sudog

  • 代表的是一个 g 的等待队列,因为g 会发生复用,一个g所关联的同步对象可能是n个,

  • 每个sudog代表的都是g所关联的一个对象

• 怎样的才是 非阻塞的发送数据给chan

  • 配合select 的发送,既是异步发送

• chan 非指针对象和指针对象的区别

  • 内存分配都是一次性分配的
  • 非指针对象,在申请内存的时候,只会申请一次(既chan的固定大小+计算得出的mem大小)
  • 指针对象: 会触发2次申请内存,第一次为先申请hchan的内存,然后申请指针的内存

• recvq和sendq的作用

  • recvq用于存储 <-c 这个操作的routine成员,当sendQ和没没有数据的时候,会打包成sudog,然后挂起
  • sendq用于存储 c<- 这个操作的goroutine,当buffer满的时候,则会打包成sudog ,然后添加到sendq,然后挂起

• 会发现在hchan中的有几个成员变量似乎是冲突的,如 qcount ,elemsize ,不都是标识长度的吗