关于GOLANG的chan

GOLANG CHAN

chan是golang中非常重要的一个东西，用来做goroutine的通信，因为golang程序必然会有多个goroutine，如何同步这些goroutine就很重要了。

使用chan时有几个心得：

首先，永远是符号<-进行读取或者写入，譬如v,ok := <-c是读取，而c <- v是写入。
其次，读取时，如果没有ok，也是可以读取的。不过如果closed也是能读的，没有赋值而已；如果要知道是否closed得加ok，也就是除非chan永远不关闭，否则读取应该用v,ok := <-c而不是用v := <-c的方式。
再次，不能向closed的chan写入，所以一般写入时需要用一个信号的chan（一般buffer为1），来判断是否写入或者放弃，用select判断是写入成功了，还是正在关闭需要放弃写入。
最后，如果closed后，chan有数据，ok还是true的，直到chan没有数据了才false。

读写Chan

永远是符号<-进行读取或者写入，譬如v,ok := <-c是读取，而c <- v是写入。

c := make(chan int, 1)
c <- 10 // 写入chan
v := <- c // 从chan中读取

下面的例子判断chan是否关闭：

c := make(chan int, 1)
c <- 10
v,ok := <- c // 读取，v=10，ok=true
close(c)
v,ok := <- c // 读取，v=0，ok=false

如果写不进去就丢弃，可以用select：

c := make(chan int, 1)

select {
case c <- 10: // c中放入了10，因为chan的buffer为1
default: 
}

select {
case c <- 11:
default: // c中只有10，没有11
}

select {
case v,ok := <- c:
    // 读出来一个，v=10, ok=true
default:
}

select {
case v,ok := <- c:
default: // 没有可读的，走这个分支
}

还可以用超时之类的，也是一个chan，(xxx)返回的就是chan。

判断closed

读取时，如果没有ok，也是可以读取的。不过如果closed也是能读的，没有赋值而已；如果要知道是否closed得加ok，也就是除非chan永远不关闭，否则读取应该用v,ok := <-c而不是用v := <-c的方式。

c := make(chan int, 1)
c <- 10
close(c)

v := <- c // c=10，读取出来一个
v = <- c // c=0，实际上没有读出来，但是判断不了

c := make(chan int, 1)
c <- 10
close(c)

v,ok := <- c // c=10,ok=true，读取出来一个
v,ok = <- c // c=0,ok=false，实际上没有读出来

写入chan

不能向closed的chan写入，所以一般写入时需要用一个信号的chan，来判断是否写入或者放弃，用select判断是写入成功了，还是正在关闭需要放弃写入。

type TcpListeners struct {
    conns  chan *
    closing chan bool
    wait *
}

func NewTcpListeners(addrs []string) (v *TcpListeners, err error) {
    v = &TcpListeners{
        addrs:     addrs,
        conns:     make(chan *),
        closing:   make(chan bool, 1),
        wait:      &{},
    }

    return
}

// Listen at addrs format as netowrk://laddr, for example,
// tcp://:1935, tcp4://:1935, tcp6://1935, tcp://0.0.0.0:1935
func (v *TcpListeners) ListenTCP() (err error) {
    for _, addr := range  {
        vs := (addr, "://")
        network, laddr := vs[0], vs[1]

        if l, err := (network, laddr); err != nil {
            return nil,err
        } else {
             = append(, l.(*))
        }
    }

    (len())
    for i, l := range  {
        addr := [i]
        go func(l *, addr string) {
            defer ()
            for {
                var conn *
                if conn, err = (); err != nil {
                    return
                }

                select {
                case  <- conn:
                case c := <-:
                     <- c
                    ()
                }
            }
        }(l, addr)
    }

    return
}

func (v *TcpListeners) AcceptTCP() (c *, err error) {
    var ok bool
    if c,ok = <- ; !ok {
        return nil, ListenerDisposed
    }
    return
}

func (v *TcpListeners) Close() (err error) {
    // unblock all listener internal goroutines
     <- true

    // interrupt all listeners.
    for _, v := range  {
        if r := (); r != nil {
            err = r
        }
    }

    // wait for all listener internal goroutines to quit.
    ()

    // clear the closing signal.
    _ = <-

    // close channels to unblock the user goroutine to AcceptTCP()
    close()

    return
}

这样在关闭Listener时，不会导致ListenTCP的goroutine写入closed的chan而导致错误。

Closed Chan

如果closed后，chan有数据，ok还是true的，直到chan没有数据了才false。

c := make(chan int, 1)
c <- 10
close(c)

v,ok := <- c // v=10,ok=true，虽然c关闭了，但是有数据，ok依然是true
v,ok <- c // v=0,ok=false，读失败了。

秒客网