1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

type hchan struct {
	qcount   uint           // total data in the queue
	dataqsiz uint           // size of the circular queue
	buf      unsafe.Pointer // points to an array of dataqsiz elements
	elemsize uint16
	closed   uint32
	elemtype *_type // element type
	sendx    uint   // send index
	recvx    uint   // receive index
	recvq    waitq  // list of recv waiters
	sendq    waitq  // list of send waiters

	// lock protects all fields in hchan, as well as several
	// fields in sudogs blocked on this channel.
	//
	// Do not change another G's status while holding this lock
	// (in particular, do not ready a G), as this can deadlock
	// with stack shrinking.
	lock mutex
}

1
2
3
4
5
6
7
8

// /usr/local/go/src/runtime/chan.go 
func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
  		.....
		if c.recvx == c.dataqsiz {
			 c.recvx = 0
		}
  		.....
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// /usr/local/go/src/runtime/chan.go 
func full(c *hchan) bool {
	// c.dataqsiz is immutable (never written after the channel is created)
	// so it is safe to read at any time during channel operation.
	if c.dataqsiz == 0 {
		// Assumes that a pointer read is relaxed-atomic.
		return c.recvq.first == nil
	}
	// Assumes that a uint read is relaxed-atomic.
	return c.qcount == c.dataqsiz
}

1
2
3
4
5
6
7
8

// /usr/local/go/src/runtime/chan.go 
func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
		....
		if !block && c.closed == 0 && full(c) {
				return false
		}
		....
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

func main() {
	ch := make(chan int, 10)
	go func() {
		for i := 0; i < 10; i++ {
			ch <- i
		}
		select {
		case ch <- 1:
		default:
			fmt.Println("no block")
		}
	}()

	time.Sleep(time.Minute)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// /usr/local/go/src/runtime/chan.go 
type waitq struct {
	first *sudog
	last  *sudog
}

type sudog struct {

	g *g

	next *sudog
	prev *sudog
	elem unsafe.Pointer


	acquiretime int64
	releasetime int64
	ticket      uint32

	isSelect bool

	success bool

	parent   *sudog // semaRoot binary tree
	waitlink *sudog // g.waiting list or semaRoot
	waittail *sudog // semaRoot
	c        *hchan // channel
}