Question

我正在向网络写数据写作goroutine是这样的。

forend:
for{
    select{
    case buf,ok:=<-sendqueue:
        if !ok{
            break forend
        }
        writeBuffer(conn,buf)
    }
}

变量conn是net.Conn。
然后我想用bufio替换net.Conn。

iowriter:=bufio.NewWriter(conn)

iowriter将缓存数据。为了减少延迟，我必须在sendqueue中没有更多数据时立即刷新iowriter。
所以我在写作goroutine

中添加了一个默认情况

forend:
for{
    select{
    case buf,ok:=<-sendqueue:
        if !ok{
            break forend
        }
        writeBuffer(iowriter,buf)
    default:
        iowriter.Flush()
        time.Sleep(time.Millisecond)
    }
}

time.Sleep是必要的，否则goroutine将运行繁忙的循环但在这种情况下，真正的需求是阻止不要睡觉最后，我找到了一个解决方案，有两个选择。

forend:
for{
    select{
    case buf,ok:=<-sendqueue:
        if !ok{
            break forend
        }
        writeBuffer(iowriter,buf)
    }
nextloop:
    for{
        select{
        case buf,ok:=<-sendqueue:
            if !ok{
                break forend
            }
            writeBuffer(iowriter,buf)
        default:
            iowriter.Flush()
            break nextloop
        }
    }
}

但是这个解决方案很复杂。第二个选择是第一个选择的副本，默认情况下。是否有更好的解决方案？

~~~~~~~~~~~~~~~~~~~~~~~更多解释
这里的行为是这样的。如果sendqueue不为空，我继续弹出数据并发送它。如果sendqueue为空，我想立即刷新iowriter中缓存的数据，然后再次等待sendqueue。
这个行为可以像这样抽象。我想在通道为空时再做一些事情，然后再次在通道上等待阻塞。我找到了两个重复的选择解决方案。但是当等待多个通道时，该解决方案可能会变得更加复杂那么我正在寻找更好的解决方案。

Answer 1

您通过两步解决方案走上正轨。

因为你想要做两件事：首先收到一个数据包（如果一个数据包还没有阻止），然后在有数据包的情况下保持接收，如果全部消耗则保持刷新，你不能用一个select声明。

但我们可以做一些简化，第一个select语句是完全没必要的，因为它只有一个case分支：

forend:
    for {
        buf, ok := <-sendqueue
        if !ok {
            break forend
        }
        writeBuffer(iowriter, buf)

    nextloop:
        for {
            select {
            case buf, ok := <-sendqueue:
                if !ok {
                    break forend
                }
                writeBuffer(iowriter, buf)
            default:
                iowriter.Flush()
                break nextloop
            }
        }
    }

由于处理接收到的数据在两种情况下都是相同的，因此您可以将该逻辑放入函数中以避免重复：

var buf datatype
var ok = true

handle := func() {
    if ok {
        writeBuffer(iowriter, buf)
    }
}

for ok {
    buf, ok = <-sendqueue
    handle()

nextloop:
    for ok {
        select {
        case buf, ok = <-sendqueue:
            handle()
        default:
            iowriter.Flush()
            break nextloop
        }
    }
}

Answer 2

我们可以通过这样的自动收报机帮助防止循环不断冲洗：

ticker := time.NewTicker(time.Millisecond * 10)
defer ticker.Stop()    
for {
        select {
        case buf,ok:=<-sendqueue:
            if !ok{
                return
            }
            writeBuffer(iowriter,buf)
        case <-ticker.C:
               iowriter.Flush()
        }
}

现在，您的数据将在准备就绪后的最后10毫秒在管道上发送。

如何在golang的select默认情况下阻止？

2 个答案: