1

我正在尝试在 Go 中编写一个函数来监视通道并记录通过它发送的内容。

func monitorChannel(inChannel, outChannel reflect.Value, fid int64, cond *sync.Cond) {
    for {       
    cond.L.Lock()
    var toLog reflect.Value
    var ok bool
    for toLog, ok = inChannel.TryRecv() ; !toLog.IsValid(); { // while no value received
        if !ok {
            cond.L.Unlock()
            return
        }
        cond.Wait()
    }
    outChannel.Send(toLog)
    logMessage("a", "b", inChannel.Interface(), toLog.Interface(), fid)
    cond.L.Unlock()
}

}

这个函数应该是从 inChannel 接收，记录发送的消息并通过 outChannel 发送。由于我希望能够记录双向通道，因此我为每个要记录的通道调用此函数两次，交换 inChannel 和 outChannel。锁是为了防止两个 goroutine 在彼此之间传递消息。“fid”只是日志文件的 id。

但是当我运行以下测试代码时，我遇到了死锁：

errsIn := make(chan int64)
errsOut := make(chan int64)
cond := sync.NewCond(&sync.Mutex{})
go monitorChannel(reflect.ValueOf(errsIn), reflect.ValueOf(errsOut), fid, cond)
go monitorChannel(reflect.ValueOf(errsOut), reflect.ValueOf(errsIn), fid,  cond)
errsIn <- 1
if <-errsOut != 1 {
    t.Fatal("lost value through channel send")
}
errsOut <- 1
if <-errsIn != 1 {
    t.Fatal("lost value through channel send")
}

即使我没有关闭通道，TryRecv 的第二个返回值似乎也返回 false。为什么是这样？我该怎么办？

我在 Windows 8 64 位上运行 go 1.0.3。

编辑

后来我发现 TryRecv 的行为有些令人困惑，并设法使用反射包和两个 sync.Locker 制作了该函数的通用版本。我还是觉得jnml的解决方案比较优雅，但是如果有人遇到过TryRecv类似的问题，看一下函数中间的注释。

func passOnAndLog(in, out reflect.Value, l1, l2 sync.Locker) {
    for {
        l1.Lock()
        val, ok := in.TryRecv()
        for !val.IsValid() { // while nothing received
            l1.Unlock()
            time.Sleep(time.Nanosecond) // pausing current thread
            l1.Lock()
            val, ok = in.TryRecv()
        }
        // if val.IsValid() == true  and ok == false ,the channel is closed
        // if val.IsValid() == false and ok == false ,the channel is open but we received nothing
        // if val.IsValid() == true  and ok == true  ,we received an actual value from the open channel
        // if val.IsValid() == false and ok == true  ,we have no idea what happened  
        if !ok {
            return
        }
        l1.Unlock()
        l2.Lock() // don't want the other thread to receive while I am sending
        out.Send(val)
        LogValue(val) // logging

        l2.Unlock()
    }
}
4

1 回答 1

2

基于反射的解决方案太复杂了，我无法弄清楚，懒惰，如果它是正确的和或可行的。（我怀疑不是，而是凭直觉。）

我会以一种更简单但非通用的方式来处理这项任务。让我们有一个通道，一些生产者将使用它来写入它，并由一些消费者使用它来读取它。

c := make(chan T, N)

可以使用一个小的辅助函数来监控这个通道，例如：

func monitored(c chan T) chan T {
        m := make(chan T, M)
        go func() {
                for v := range c {
                        m <- v
                        logMessage(v)
                }
                close(m)
        }()
        return m
}

现在足以：

mc := monitored(c)

和

  • 传递c给生产者，但mc传递给消费者。
  • 完成后关闭c以不泄漏 goroutine。

警告：上面的代码根本没有经过测试。

于 2013-03-10T08:59:35.550 回答