19-chan原理3-发送

5. 发送chan

由汇编可以看出，向chan发送数据会转化为对runtime.chansend1()->chansend()->send()的调用。

        tmp :=9999
        var_chan_1 <- tmp
    0x00fb 00251 (channel.go:32)    MOVQ    $9999, ""..autotmp_6+64(SP)
    0x0104 00260 (channel.go:32)    PCDATA  $2, $1
    0x0104 00260 (channel.go:32)    MOVQ    "".var_chan_1+96(SP), AX
    0x0109 00265 (channel.go:32)    PCDATA  $2, $0
    0x0109 00265 (channel.go:32)    MOVQ    AX, (SP)
    0x010d 00269 (channel.go:32)    PCDATA  $2, $1
    0x010d 00269 (channel.go:32)    LEAQ    ""..autotmp_6+64(SP), AX
    0x0112 00274 (channel.go:32)    PCDATA  $2, $0
    0x0112 00274 (channel.go:32)    MOVQ    AX, 8(SP)
    0x0117 00279 (channel.go:32)    CALL    runtime.chansend1(SB)

5.1 chansend1

对chansend()的简单封装。

// entry point for c <- x from compiled code
//go:nosplit
func chansend1(c *hchan, elem unsafe.Pointer) {
	chansend(c, elem, true, getcallerpc())
}

5.2 chansend

1. 对nil chan发送
   1. 非阻塞发送，直接返回。
   2. 阻塞发送，调用gopark()将当前goroutine挂起。
2. 对已被关闭的chan，非阻塞调用时进行快速检查，判断是否可以进行发送。两种情形不能发送。
   1. 发送缓存队列长度为空。并且，等待接收队列为空。(c.dataqsiz == 0 && c.recvq.first == nil)
   2. 发送缓存队列满了。(c.dataqsiz > 0 && c.qcount == c.dataqsiz)
3. 发送过程会对chan加锁。
4. 判断chan是否被关闭，向已经关闭的chan发送数据，会panic。
5. 如果等待接收队列不空（说明缓存中无数据），直接向第一个等待接收对象发送数据，不再经过缓冲。返回。
6. 如果缓存队列未满，则将数据放入缓存队列。返回。
7. 对于非阻塞的，缓存队列已经满了，或者没有缓存队列，且等待接收队列为空，则直接返回。
8. 创建一个sudog对象，放入等待发送队列。将当前goroutine挂起。等待可以发送时被唤醒。

/*
 * generic single channel send/recv
 * If block is not nil,
 * then the protocol will not
 * sleep but return if it could
 * not complete.
 *
 * sleep can wake up with g.param == nil
 * when a channel involved in the sleep has
 * been closed.  it is easiest to loop and re-run
 * the operation; we'll see that it's now closed.
 */
func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
	if c == nil {
		if !block {
			return false
		}
		gopark(nil, nil, waitReasonChanSendNilChan, traceEvGoStop, 2)
		throw("unreachable")
	}

	if debugChan {
		print("chansend: chan=", c, "\n")
	}

	if raceenabled {
		racereadpc(c.raceaddr(), callerpc, funcPC(chansend))
	}

	// Fast path: check for failed non-blocking operation without acquiring the lock.
	//
	// After observing that the channel is not closed, we observe that the channel is
	// not ready for sending. Each of these observations is a single word-sized read
	// (first c.closed and second c.recvq.first or c.qcount depending on kind of channel).
	// Because a closed channel cannot transition from 'ready for sending' to
	// 'not ready for sending', even if the channel is closed between the two observations,
	// they imply a moment between the two when the channel was both not yet closed
	// and not ready for sending. We behave as if we observed the channel at that moment,
	// and report that the send cannot proceed.
	//
	// It is okay if the reads are reordered here: if we observe that the channel is not
	// ready for sending and then observe that it is not closed, that implies that the
	// channel wasn't closed during the first observation.
	if !block && c.closed == 0 && ((c.dataqsiz == 0 && c.recvq.first == nil) ||
		(c.dataqsiz > 0 && c.qcount == c.dataqsiz)) {
		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"))
	}

	if sg := c.recvq.dequeue(); sg != nil {
		// Found a waiting receiver. We pass the value we want to send
		// directly to the receiver, bypassing the channel buffer (if any).
		send(c, sg, ep, func() { unlock(&c.lock) }, 3)
		return true
	}

	if c.qcount < c.dataqsiz {
		// Space is available in the channel buffer. Enqueue the element to send.
		qp := chanbuf(c, c.sendx)
		if raceenabled {
			raceacquire(qp)
			racerelease(qp)
		}
		typedmemmove(c.elemtype, qp, ep)
		c.sendx++
		if c.sendx == c.dataqsiz {
			c.sendx = 0
		}
		c.qcount++
		unlock(&c.lock)
		return true
	}

	if !block {
		unlock(&c.lock)
		return false
	}

	// Block on the channel. Some receiver will complete our operation for us.
	gp := getg()
	mysg := acquireSudog()
	mysg.releasetime = 0
	if t0 != 0 {
		mysg.releasetime = -1
	}
	// No stack splits between assigning elem and enqueuing mysg
	// on gp.waiting where copystack can find it.
	mysg.elem = ep
	mysg.waitlink = nil
	mysg.g = gp
	mysg.isSelect = false
	mysg.c = c
	gp.waiting = mysg
	gp.param = nil
	c.sendq.enqueue(mysg)
	goparkunlock(&c.lock, waitReasonChanSend, traceEvGoBlockSend, 3)
	// Ensure the value being sent is kept alive until the
	// receiver copies it out. The sudog has a pointer to the
	// stack object, but sudogs aren't considered as roots of the
	// stack tracer.
	KeepAlive(ep)

	// someone woke us up.
	if mysg != gp.waiting {
		throw("G waiting list is corrupted")
	}
	gp.waiting = nil
	if gp.param == nil {
		if c.closed == 0 {
			throw("chansend: spurious wakeup")
		}
		panic(plainError("send on closed channel"))
	}
	gp.param = nil
	if mysg.releasetime > 0 {
		blockevent(mysg.releasetime-t0, 2)
	}
	mysg.c = nil
	releaseSudog(mysg)
	return true
}

5.3 send

1. 判断等待接收方是否有设置待接收对象sg.elem，有则直接将数据放到sg.elem所指位置，同时置sg.elem=nil。
2. 调用goready()，唤醒等待接收gorotine。

// send processes a send operation on an empty channel c.
// The value ep sent by the sender is copied to the receiver sg.
// The receiver is then woken up to go on its merry way.
// Channel c must be empty and locked.  send unlocks c with unlockf.
// sg must already be dequeued from c.
// ep must be non-nil and point to the heap or the caller's stack.
func send(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
	if raceenabled {
		if c.dataqsiz == 0 {
			racesync(c, sg)
		} else {
			// Pretend we go through the buffer, even though
			// we copy directly. Note that we need to increment
			// the head/tail locations only when raceenabled.
			qp := chanbuf(c, c.recvx)
			raceacquire(qp)
			racerelease(qp)
			raceacquireg(sg.g, qp)
			racereleaseg(sg.g, qp)
			c.recvx++
			if c.recvx == c.dataqsiz {
				c.recvx = 0
			}
			c.sendx = c.recvx // c.sendx = (c.sendx+1) % c.dataqsiz
		}
	}
	if sg.elem != nil {
		sendDirect(c.elemtype, sg, ep)
		sg.elem = nil
	}
	gp := sg.g
	unlockf()
	gp.param = unsafe.Pointer(sg)
	if sg.releasetime != 0 {
		sg.releasetime = cputicks()
	}
	goready(gp, skip+1)
}