Go源码学习: 往channel中发送数据的内部实现是什么样的?

 1> runtime.chansend1() /usr/local/Cellar/go/1.17.2/libexec/src/runtime/chan.go:143 (PC: 0x1003a8e)
 2Warning: debugging optimized function
 3   138: }
 4   139:
 5   140: // entry point for c <- x from compiled code
 6   141: //go:nosplit
 7   142: func chansend1(c *hchan, elem unsafe.Pointer) {
 8=> 143:         chansend(c, elem, true, getcallerpc())
 9   144: }
10   145:
11   146: /*
12   147:  * generic single channel send/recv
13   148:  * If block is not nil,

1   158: func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
2=> 159:         if c == nil {
3   160:                 if !block {
4   161:                         return false
5   162:                 }
6   163:                 gopark(nil, nil, waitReasonChanSendNilChan, traceEvGoStop, 2)

1	if c == nil {
2		if !block {
3			return false
4		}
5		gopark(nil, nil, waitReasonChanSendNilChan, traceEvGoStop, 2)
6		throw("unreachable")
7	}

1	if !block && c.closed == 0 && full(c) {
2		return false
3	}

 1func full(c *hchan) bool {
 2	// c.dataqsiz is immutable (never written after the channel is created)
 3	// so it is safe to read at any time during channel operation.
 4	if c.dataqsiz == 0 {
 5		// Assumes that a pointer read is relaxed-atomic.
 6		return c.recvq.first == nil
 7	}
 8	// Assumes that a uint read is relaxed-atomic.
 9	return c.qcount == c.dataqsiz
10}

1	lock(&c.lock)
2
3	if c.closed != 0 {
4		unlock(&c.lock)
5		panic(plainError("send on closed channel"))
6	}

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

 1func send(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
 2	if raceenabled {
 3		if c.dataqsiz == 0 {
 4			racesync(c, sg)
 5		} else {
 6			// Pretend we go through the buffer, even though
 7			// we copy directly. Note that we need to increment
 8			// the head/tail locations only when raceenabled.
 9			racenotify(c, c.recvx, nil)
10			racenotify(c, c.recvx, sg)
11			c.recvx++
12			if c.recvx == c.dataqsiz {
13				c.recvx = 0
14			}
15			c.sendx = c.recvx // c.sendx = (c.sendx+1) % c.dataqsiz
16		}
17	}
18	if sg.elem != nil {
19		sendDirect(c.elemtype, sg, ep)
20		sg.elem = nil
21	}
22	gp := sg.g
23	unlockf()
24	gp.param = unsafe.Pointer(sg)
25	sg.success = true
26	if sg.releasetime != 0 {
27		sg.releasetime = cputicks()
28	}
29	goready(gp, skip+1)
30}

 1	if c.qcount < c.dataqsiz {
 2		// Space is available in the channel buffer. Enqueue the element to send.
 3		qp := chanbuf(c, c.sendx)
 4		if raceenabled {
 5			racenotify(c, c.sendx, nil)
 6		}
 7		typedmemmove(c.elemtype, qp, ep)
 8		c.sendx++
 9		if c.sendx == c.dataqsiz {
10			c.sendx = 0
11		}
12		c.qcount++
13		unlock(&c.lock)
14		return true
15	}

1	if !block {
2		unlock(&c.lock)
3		return false
4	}

 1	// Block on the channel. Some receiver will complete our operation for us.
 2	gp := getg()
 3	mysg := acquireSudog()
 4	mysg.releasetime = 0
 5	if t0 != 0 {
 6		mysg.releasetime = -1
 7	}
 8	// No stack splits between assigning elem and enqueuing mysg
 9	// on gp.waiting where copystack can find it.
10	mysg.elem = ep
11	mysg.waitlink = nil
12	mysg.g = gp
13	mysg.isSelect = false
14	mysg.c = c
15	gp.waiting = mysg
16	gp.param = nil
17	c.sendq.enqueue(mysg)
18	// Signal to anyone trying to shrink our stack that we're about
19	// to park on a channel. The window between when this G's status
20	// changes and when we set gp.activeStackChans is not safe for
21	// stack shrinking.
22	atomic.Store8(&gp.parkingOnChan, 1)
23	gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanSend, traceEvGoBlockSend, 2)
24	// Ensure the value being sent is kept alive until the
25	// receiver copies it out. The sudog has a pointer to the
26	// stack object, but sudogs aren't considered as roots of the
27	// stack tracer.
28	KeepAlive(ep)
29
30	// someone woke us up.
31	if mysg != gp.waiting {
32		throw("G waiting list is corrupted")
33	}
34	gp.waiting = nil
35	gp.activeStackChans = false
36	closed := !mysg.success
37	gp.param = nil
38	if mysg.releasetime > 0 {
39		blockevent(mysg.releasetime-t0, 2)
40	}
41	mysg.c = nil
42	releaseSudog(mysg)
43	if closed {
44		if c.closed == 0 {
45			throw("chansend: spurious wakeup")
46		}
47		panic(plainError("send on closed channel"))
48	}
49	return true