GOLANG CHAN

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

使用chan时有几个心得:

1. 首先,永远是符号<-进行读取或者写入,譬如v,ok := <-c是读取,而c <- v是写入。
2. 其次,读取时,如果没有ok,也是可以读取的。不过如果closed也是能读的,没有赋值而已;如果要知道是否closed得加ok,也就是除非chan永远不关闭,否则读取应该用v,ok := <-c而不是用v := <-c的方式。
3. 再次,不能向closed的chan写入,所以一般写入时需要用一个信号的chan(一般buffer为1),来判断是否写入或者放弃,用select判断是写入成功了,还是正在关闭需要放弃写入。
4. 最后,如果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,time.After(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 *net.TCPConn
 closing chan bool
 wait *sync.WaitGroup
}
func NewTcpListeners(addrs []string) (v *TcpListeners, err error) {
 v = &TcpListeners{
 addrs: addrs,
 conns: make(chan *net.TCPConn),
 closing: make(chan bool, 1),
 wait: &sync.WaitGroup{},
 }
 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 v.addrs {
 vs := strings.Split(addr, "://")
 network, laddr := vs[0], vs[1]
 if l, err := net.Listen(network, laddr); err != nil {
 return nil,err
 } else {
 v.listeners = append(v.listeners, l.(*net.TCPListener))
 }
 }
 v.wait.Add(len(v.listeners))
 for i, l := range v.listeners {
 addr := v.addrs[i]
 go func(l *net.TCPListener, addr string) {
 defer v.wait.Done()
 for {
 var conn *net.TCPConn
 if conn, err = l.AcceptTCP(); err != nil {
 return
 }
 select {
 case v.conns <- conn:
 case c := <-v.closing:
 v.closing <- c
 conn.Close()
 }
 }
 }(l, addr)
 }
 return
}
func (v *TcpListeners) AcceptTCP() (c *net.TCPConn, err error) {
 var ok bool
 if c,ok = <- v.conns; !ok {
 return nil, ListenerDisposed
 }
 return
}
func (v *TcpListeners) Close() (err error) {
 // unblock all listener internal goroutines
 v.closing <- true
 // interrupt all listeners.
 for _, v := range v.listeners {
 if r := v.Close(); r != nil {
 err = r
 }
 }
 // wait for all listener internal goroutines to quit.
 v.wait.Wait()
 // clear the closing signal.
 _ = <-v.closing
 // close channels to unblock the user goroutine to AcceptTCP()
 close(v.conns)
 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,读失败了。

有疑问加站长微信联系(非本文作者)

• 请尽量让自己的回复能够对别人有帮助
• 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
• 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
• 图片支持拖拽、截图粘贴等方式上传