Question

我有一个存储接收数据的频道，我想在满足以下条件之一时处理它：
1，通道达到其容量 2，自上次进程以来，计时器被触发。

我看到了帖子 Golang - How to know a buffered channel is full

更新

我从该帖子和OneOfOne的建议中获得灵感，这里是play：

package main

import (
    "fmt"
    "math/rand"
    "time"
)

var c chan int
var timer *time.Timer

const (
    capacity     = 5
    timerDration = 3
)

func main() {
    c = make(chan int, capacity)
    timer = time.NewTimer(time.Second * timerDration)
    go checkTimer()
    go sendRecords("A")
    go sendRecords("B")
    go sendRecords("C")

    time.Sleep(time.Second * 20)
}

func sendRecords(name string) {
    for i := 0; i < 20; i++ {
        fmt.Println(name+" sending record....", i)
        sendOneRecord(i)
        interval := time.Duration(rand.Intn(500))
        time.Sleep(time.Millisecond * interval)
    }
}

func sendOneRecord(record int) {
    select {
    case c <- record:
    default:
        fmt.Println("channel is full !!!")
        process()
        c <- record
        timer.Reset(time.Second * timerDration)
    }
}

func checkTimer() {
    for {
        select {
        case <-timer.C:
            fmt.Println("3s timer ----------")
            process()
            timer.Reset(time.Second * timerDration)
        }
    }
}

func process() {
    for i := 0; i < capacity; i++ {
        fmt.Println("process......", <-c)
    }
}

这似乎工作正常，但我有一个问题，我想在调用process（）时阻止从其他goroutine写入通道，上面的代码是否能够这样做？或者我应该在流程方法的开头添加一个互斥量？

任何优雅的解决方案？

Answer 1

不，选择是唯一的方法：

func (t *T) Send(v *Val) {
    select {
    case t.ch <- v:
    default:
        // handle v directly
    }
}

Answer 2

正如@OneOfOne所提到的，select是检查频道是否已满的唯一方法。

如果您使用频道进行批量处理，您可以随时创建一个无缓冲的频道并使用goroutine拉项并附加到切片。

当切片达到特定大小时，处理项目。

以下是play

的示例

package main

import (
    "fmt"
    "sync"
    "time"
)

const BATCH_SIZE = 10

func batchProcessor(ch <-chan int) {
    batch := make([]int, 0, BATCH_SIZE)
    for i := range ch {
        batch = append(batch, i)
        if len(batch) == BATCH_SIZE {
            fmt.Println("Process batch:", batch)
            time.Sleep(time.Second)
            batch = batch[:0] // trim back to zero size
        }
    }
    fmt.Println("Process last batch:", batch)
}
func main() {
    var wg sync.WaitGroup
    ch := make(chan int)
    wg.Add(1)
    go func() {
        batchProcessor(ch)
        wg.Done()
    }()
    fmt.Println("Submitting tasks")
    for i := 0; i < 55; i++ {
        ch <- i
    }
    close(ch)
    wg.Wait()
}

如何在Golang中正确处理缓冲通道？

2 个答案: