Go channel结构剖析《一》

type hchan struct {
  qcount   uint
  dataqsiz uint
  buf      unsafe.Pointer
  elemsize uint16
  closed   uint32
  elemtype *_type
  sendx    uint
  recvx    uint
  recvq    waitq
  sendq    waitq
  lock mutex
}

type waitq struct {
  first *sudog //指向双向链表头节点
  last  *sudog //指向双向链表未节点
}

// sudog represents a g in a wait list, such as for sending/receiving
// on a channel.
//
// sudog is necessary because the g ↔ synchronization object relation
// is many-to-many. A g can be on many wait lists, so there may be
// many sudogs for one g; and many gs may be waiting on the same
// synchronization object, so there may be many sudogs for one object.
//
// sudogs are allocated from a special pool. Use acquireSudog and
// releaseSudog to allocate and free them.
type sudog struct {
  // The following fields are protected by the hchan.lock of the
  // channel this sudog is blocking on. shrinkstack depends on
  // this for sudogs involved in channel ops.
  g *g
  next *sudog //下一个元素
  prev *sudog //前一个元素 用于实现双向链表
  elem unsafe.Pointer // data element (may point to stack)
  // The following fields are never accessed concurrently.
  // For channels, waitlink is only accessed by g.
  // For semaphores, all fields (including the ones above)
  // are only accessed when holding a semaRoot lock.
  acquiretime int64
  releasetime int64
  ticket      uint32
  // isSelect indicates g is participating in a select, so
  // g.selectDone must be CAS'd to win the wake-up race.
  isSelect bool
  // success indicates whether communication over channel c
  // succeeded. It is true if the goroutine was awoken because a
  // value was delivered over channel c, and false if awoken
  // because c was closed.
  success bool
  parent   *sudog // semaRoot binary tree
  waitlink *sudog // g.waiting list or semaRoot
  waittail *sudog // semaRoot
  c        *hchan // channel
}

//入双向队列
func (q *waitq) enqueue(sgp *sudog) {
  sgp.next = nil
  x := q.last
  if x == nil {
    sgp.prev = nil
    q.first = sgp
    q.last = sgp
    return
  }
  sgp.prev = x
  x.next = sgp
  q.last = sgp
}
//出双向队列
func (q *waitq) dequeue() *sudog {
  for {
    sgp := q.first
    if sgp == nil {
      return nil
    }
    y := sgp.next
    if y == nil {
      q.first = nil
      q.last = nil
    } else {
      y.prev = nil
      q.first = y
      sgp.next = nil // mark as removed (see dequeueSudog)
    }
    // if a goroutine was put on this queue because of a
    // select, there is a small window between the goroutine
    // being woken up by a different case and it grabbing the
    // channel locks. Once it has the lock
    // it removes itself from the queue, so we won't see it after that.
    // We use a flag in the G struct to tell us when someone
    // else has won the race to signal this goroutine but the goroutine
    // hasn't removed itself from the queue yet.
    if sgp.isSelect && !atomic.Cas(&sgp.g.selectDone, 0, 1) {
      continue
    }
    return sgp
  }
}