golang怎么判断chan已经关闭

我们都知道data, ok := <- chan第一个变量表示读出的数据，第二个变量表示是否成功读取了数据，有意思的是，第二个变量并不用于指示管道的关闭的状态。第二个变量常常被误以为关闭状态是因为它确实和管道状态有关，确切的来说，是和管道缓冲区是否有数据有关。

如果判断golang的channel是否关闭，data, ok := <- chan，当ok不是true的时候，说明是channel关闭了。 那么问题来了，channel关闭了，我们是否可以立马获取到channel被关闭的状态？我想这个问题不少人没有去想吧？为什么有这样的问题？  来自我的一个bug，我期初认为close了一个channel，消费端的goroutine自然是可以拿到channel的关闭状态。然而事实并不是这样的。 只有当channel无数据，且channel被close了，才会返回ok=false。  所以，只要有堆积，就不会返回关闭状态。导致我的服务花时间来消费堆积，才会退出。

测试channel的关闭状态

package main



import (

    "fmt"

)



func main() {

    c := make(chan int, 10)

    c <- 1

    c <- 2

    c <- 3

    close(c)

    for {

        i,  ok := <-c

        fmt.Println(ok)

        if !ok {

            fmt.Println("channel closed!")

            break

        }

        fmt.Println(i)

    }

}

 

我们发现已经把channel关闭了，只要有堆积的数据，那么ok就不为false，不为关闭的状态。

go runtime channel源码分析

   首先我们来分析下go runtime/chan.go的相关源码，记得先前写过一篇golang channel实现的源码分析，有兴趣的朋友可以翻翻。 这次翻channel源码主要探究下close chan过程及怎么查看channel是否关闭？

   下面是channel的hchan主数据结构，closed字段就是标明是否退出的标识。

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

        ...

}

下面是关闭channel的函数，修改了closed字段为1, 1为退出。

//go:linkname reflect_chanclose reflect.chanclose

func reflect_chanclose(c *hchan) {

closechan(c)

}



func closechan(c *hchan) {

if c == nil {

panic(plainError("close of nil channel"))

}



lock(&c.lock)

if c.closed != 0 {

unlock(&c.lock)

panic(plainError("close of closed channel"))

}

        ....

c.closed = 1

        ...

}

    下面是channel的recv消费者方法，也就是 data, ok := <- chan。if c.closed != 0 && c.qcount == 0 只有当 closed为1 并且 堆积为0的时候，才会返回false。 一句话，channel已经closed，并且没有堆积任务，才会返回关闭channel的状态。

func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {

        ....

lock(&c.lock)



if c.closed != 0 && c.qcount == 0 {

if raceenabled {

raceacquire(unsafe.Pointer(c))

}

unlock(&c.lock)

if ep != nil {

typedmemclr(c.elemtype, ep)

}

return true, false

}



if sg := c.sendq.dequeue(); sg != nil {

recv(c, sg, ep, func() { unlock(&c.lock) }, 3)

return true, true

}



if c.qcount > 0 {

// Receive directly from queue

qp := chanbuf(c, c.recvx)

c.qcount--

unlock(&c.lock)

return true, true

}

   ...

}

channel代码里没有找到一个查询channel关闭的方法。

解决方法

那么如何在channel堆积的情况下，得知channel已经关闭了 ？

第一种方法:

可以直接读取channel结构hchan的closed字段，但问题chan.go没有开放这样的api，所以我们要用reflect这个黑科技了。  （不推荐大家用reflect的方法，因为看起来太黑科技了）

import (

    "unsafe"

    "reflect"

)



func isChanClosed(ch interface{}) bool {

    if reflect.TypeOf(ch).Kind() != reflect.Chan {

        panic("only channels!")

    }

    cptr := *(*uintptr)(unsafe.Pointer(

        unsafe.Pointer(uintptr(unsafe.Pointer(&ch)) + unsafe.Sizeof(uint(0))),

    ))



    // this function will return true if chan.closed > 0

    // see hchan on https://github.com/golang/go/blob/master/src/runtime/chan.go

    // 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

    // **



    cptr += unsafe.Sizeof(uint(0))*2

    cptr += unsafe.Sizeof(unsafe.Pointer(uintptr(0)))

    cptr += unsafe.Sizeof(uint16(0))

    return *(*uint32)(unsafe.Pointer(cptr)) > 0

}

第二种方法:

配合一个context或者一个变量来做。就拿context来说，那么select不仅可以读取数据chan，且同时监听<- context.Done() , 当context.Done()有事件，直接退出就ok了。

 ...

ctx, cancel := context.WithCancel(context.Background())

close(c)

cancel()

exit:

for {

select {

case data, ok := <-c:

fmt.Println(data, ok)



case <-ctx.Done():

break exit

}

}

     ...