golang的引用类型的数据类型有三个chan、slice、map，虽然golang的函数的参数都是值传递,传递引用类型参数只会拷贝参数的变量，实际引用的地址仍然是一个，所以会改变函数外部的变量的值，产生变量逃逸到堆的现象。废话优点多了，今天看一眼golang的chan类型，chan类型是设计用来做goroutine通信的，类似unix的管道，如果了跨进程的通信还是用分布式来解决比较好，chan解决的是goroutine之间的通信。先看一下源码src/runtime/chan.go：hchan 32行，我的版本是1.13.5

 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 //chan是否已经关闭

    elemtype *_type // element type 元素类型

    sendx uint // send index 写入新的元素存放位置

    recvx uint // receive index 读取元素的位置

    recvq waitq // list of recv waiters 等待读的goroutine队列

    sendq waitq // list of send waiters 等待写的goroutine队列

  // 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 //互斥锁

}  

基本上是实现了一个环形队列，如果是缓冲队列环形队列作为缓冲区，队列的长度make(chan string, len)时由len指定，就是可以缓冲多少个元素，qcount标识还有多少个空闲的缓冲位置，buf指针指向队列的地址，sendx是新写入元素写入的队列的下标，recvx是下次读出数据的队列的下标。

chan通过两个队列和一个互斥锁实现不同goroutine的同步。首先如果chan的缓冲区满了,读写goroutine都会阻塞，会分别在recvq和sendq两个队列里挂起等待被唤醒；在有新的数据写入chan时recvq队列等待的读goroutine会被唤起，同样写队列会在chan缓冲有空位的时候唤起；无缓冲的chan的qcount=0，这时recvq和sendq肯定有一个队列是空的一个不是空的，因为没有位置区缓冲，只能在写入时候唤起读去读出来，同样写也只能在有读队列在等待的情况下写入，否则会panic。同一个chan只能允许一个goroutine读写是lock mutex互斥锁实现的。

chan结构体包含定义的元素的数据格式elemtype，只能存储指定类型的值；elemsize是元素的大小，用于找到buf中的位置。

初始化chan，make(chan string， len)len执行缓冲长度，string指定元素类型，buf大小由长度和元素大小共同决定；下面函数基本上就是创建hchan的数据结构和类型内存安全的判断

 func makechan(t *chantype, size int) *hchan {

        elem := t.elem

        // compiler checks this but be safe.

        if elem.size >= 1<<16 {

        throw("makechan: invalid channel element type")

        }

        if hchanSize%maxAlign != 0 || elem.align > maxAlign {

        throw("makechan: bad alignment")

        }

        mem, overflow := math.MulUintptr(elem.size, uintptr(size))

        if overflow || mem > maxAlloc-hchanSize || size < 0 {

        panic(plainError("makechan: size out of range"))

        }

        // Hchan does not contain pointers interesting for GC when elements stored in buf do not contain pointers.

        // buf points into the same allocation, elemtype is persistent.

        // SudoG's are referenced from their owning thread so they can't be collected.

        // TODO(dvyukov,rlh): Rethink when collector can move allocated objects.

        var c *hchan

        switch {

        case mem == 0:

        // Queue or element size is zero.

        c = (*hchan)(mallocgc(hchanSize, nil, true))

        // Race detector uses this location for synchronization.

        c.buf = c.raceaddr()

        case elem.ptrdata == 0:

        // Elements do not contain pointers.

        // Allocate hchan and buf in one call.

        c = (*hchan)(mallocgc(hchanSize+mem, nil, true))

        c.buf = add(unsafe.Pointer(c), hchanSize)

        default:

        // Elements contain pointers.

        c = new(hchan)

        c.buf = mallocgc(mem, elem, true)

        }

        c.elemsize = uint16(elem.size)

        c.elemtype = elem

        c.dataqsiz = uint(size)

        if debugChan {

        print("makechan: chan=", c, "; elemsize=", elem.size, "; elemalg=", elem.alg, "; dataqsiz=", size, "\n")

        }

        return c

}  

写chan就是先判断等待队列是否空，不空就从recvq取出一个goroutine把数据写入，唤醒这个goroutine；如果没有等待的读groutine，就写入缓冲区，缓冲区没有位置就把写入数据写入当前goroutine在sendq排队挂起等待被唤起。

读chan同样，先读缓冲区数据，缓冲区数据，判断sendq是否为空，不空则把goroutine唤起写入缓冲，读结束；没有数据可读则加入recvq队列挂起等待唤起。

关闭chan，会清理recvq和sendq的队列；sendq队列的goroutine会panic，recvq队列的goroutine写入的数据设置为空就是nil；所以关闭的chan继续写入会panic，但是还是能读关闭chan的buf数据。

常用使用demo：

单向队列

 func main() {

    var c = make(chan int, 10)

    writeChan(c)

    readChan(c)

}

func readChan(flow <-chan int) {

    reciter := <-flow

    fmt.Println(reciter)

}

func writeChan(flow chan <-int) {

flow<-1

}  

多路io监听由select实现

 func addNumberToChan(chanName chan int) {

for {

chanName <- 1

time.Sleep(1 * time.Second)

}

}

func main() {

    var chan1 = make(chan int, 10)

    var chan2 = make(chan int, 10)

    go addNumberToChan(chan1)

    go addNumberToChan(chan2)

    for {

        select {

          case e := <-chan1:

          fmt.Printf("Get element from chan1: %d\n", e)

        case e := <-chan2:

        fmt.Printf("Get element from chan2: %d\n", e)

         default:

              fmt.Printf("No element in chan1 and chan2.\n")

              time.Sleep(1 * time.Second)

        }

    }

}  

select监听多路io就是多个chan，没有chan有数据会走default代码块，顺序是随机轮询的没有default语句的话select也会继续循环轮询监听

range循环从chan读数据，就是遍历buf数组，当chan没有数据会阻塞到goroutine

 func chanRange(chanName chan int) {
    for e := range chanName {
        fmt.Printf("Get element from chan: %d\n", e) 
    }
}