Question

我很好奇频道的行为以及它们与循环相关的工作方式。假设我有以下代码：

消费

tick := time.Tick(time.Duration(2) * time.Second)
for {
    select {
    case <-tick:
        p.channel <-true
    }
}

我有一个具有以下内容的goroutine：

处理器

for {
    select {
    case canProcess := <-p.channel:
        // synchronous process that takes longer than 2 seconds
    case <-p.stop:
        return
    }
}

当消费者推送到频道的速度超过处理器可以完成其同步过程时会发生什么？

他们是否堆积等待处理器完成或者是否跳过“节拍”？

如果它们堆积起来，是否存在内存泄漏的可能性？

我知道我可以将同步过程放在goroutine中，但这实际上是为了理解通道的行为方式。（即我的例子有2秒的刻度，但它不必）。

Answer 1

select将仅在下次调用。如果前一个案例对应代码已完成，则选中，
你可以通过指定通道的大小，即channel：= make（chan bool，10）

来获得一些杠杆

见下文：

func main() {

    channel := make(chan bool, 10)
    go func() {
        tick := time.Tick(time.Duration(1) * time.Second)
        for {
            select {
            case <-tick:
                fmt.Printf("Producer: TICK %v\n", time.Now())
                channel <- true
                }
        }
    }()

    for {
        select {
        case canProcess := <-channel:
            time.Sleep(3*  time.Second)
            fmt.Printf("Consumer: Completed : %v\n")
            fmt.Printf("%v\n", canProcess)
        }
    }
}

for循环的golang通道行为

1 个答案: