在 n 秒后中断的循环
For loop that breaks after n amount of seconds
我怎样才能让这个简单的 for
循环在执行后恰好经过一个 1 之后中断?
var i int
for {
i++
}
通过检查自开始以来经过的时间:
var i int
for start := time.Now(); time.Since(start) < time.Second; {
i++
}
或使用 "timeout" 渠道,通过调用 time.After()
获得。使用 select
检查时间是否已到,但您必须添加一个 default
分支,以便它成为 non-blocking 检查。如果时间到了,则退出循环。使用标签并从 for
循环中断也很重要,否则 break
将直接从 select
中断,这将是一个无限循环。
loop:
for timeout := time.After(time.Second); ; {
select {
case <-timeout:
break loop
default:
}
i++
}
注意:如果循环体还执行通信操作(如发送或接收),使用超时通道可能是唯一可行的选择! (您可以在同一个 select
中列出超时检查和循环的通信操作。)
我们可能会重写超时通道解决方案以不使用标签:
for stay, timeout := true, time.After(time.Second); stay; {
i++
select {
case <-timeout:
stay = false
default:
}
}
优化
我知道你的循环只是一个例子,但如果循环只做一点点工作,就不值得在每次迭代中检查超时。我们可以重写第一个解决方案来检查超时,例如在这样的每 10 次迭代中:
var i int
for start := time.Now(); ; {
if i % 10 == 0 {
if time.Since(start) > time.Second {
break
}
}
i++
}
我们可以选择一个迭代次数,它是 2 的倍数,然后我们可以使用位掩码,它应该比余数检查更快:
var i int
for start := time.Now(); ; {
if i&0x0f == 0 { // Check in every 16th iteration
if time.Since(start) > time.Second {
break
}
}
i++
}
我们也可以计算一次结束时间(循环必须结束的时间),然后你只需要将当前时间与此进行比较:
var i int
for end := time.Now().Add(time.Second); ; {
if i&0x0f == 0 { // Check in every 16th iteration
if time.Now().After(end) {
break
}
}
i++
}
我知道这个问题有点老了,但下面的内容可能对寻找类似场景的人有用:
func keepCheckingSomething() (bool, error) {
timeout := time.After(10 * time.Second)
ticker := time.Tick(500 * time.Millisecond)
// Keep trying until we're timed out or get a result/error
for {
select {
// Got a timeout! fail with a timeout error
case <-timeout:
return false, errors.New("timed out")
// Got a tick, we should check on checkSomething()
case <-ticker:
ok, err := checkSomething()
if err != nil {
// We may return, or ignore the error
return false, err
// checkSomething() done! let's return
} else if ok {
return true, nil
}
// checkSomething() isn't done yet, but it didn't fail either, let's try again
}
}
}
我怎样才能让这个简单的 for
循环在执行后恰好经过一个 1 之后中断?
var i int
for {
i++
}
通过检查自开始以来经过的时间:
var i int
for start := time.Now(); time.Since(start) < time.Second; {
i++
}
或使用 "timeout" 渠道,通过调用 time.After()
获得。使用 select
检查时间是否已到,但您必须添加一个 default
分支,以便它成为 non-blocking 检查。如果时间到了,则退出循环。使用标签并从 for
循环中断也很重要,否则 break
将直接从 select
中断,这将是一个无限循环。
loop:
for timeout := time.After(time.Second); ; {
select {
case <-timeout:
break loop
default:
}
i++
}
注意:如果循环体还执行通信操作(如发送或接收),使用超时通道可能是唯一可行的选择! (您可以在同一个 select
中列出超时检查和循环的通信操作。)
我们可能会重写超时通道解决方案以不使用标签:
for stay, timeout := true, time.After(time.Second); stay; {
i++
select {
case <-timeout:
stay = false
default:
}
}
优化
我知道你的循环只是一个例子,但如果循环只做一点点工作,就不值得在每次迭代中检查超时。我们可以重写第一个解决方案来检查超时,例如在这样的每 10 次迭代中:
var i int
for start := time.Now(); ; {
if i % 10 == 0 {
if time.Since(start) > time.Second {
break
}
}
i++
}
我们可以选择一个迭代次数,它是 2 的倍数,然后我们可以使用位掩码,它应该比余数检查更快:
var i int
for start := time.Now(); ; {
if i&0x0f == 0 { // Check in every 16th iteration
if time.Since(start) > time.Second {
break
}
}
i++
}
我们也可以计算一次结束时间(循环必须结束的时间),然后你只需要将当前时间与此进行比较:
var i int
for end := time.Now().Add(time.Second); ; {
if i&0x0f == 0 { // Check in every 16th iteration
if time.Now().After(end) {
break
}
}
i++
}
我知道这个问题有点老了,但下面的内容可能对寻找类似场景的人有用:
func keepCheckingSomething() (bool, error) {
timeout := time.After(10 * time.Second)
ticker := time.Tick(500 * time.Millisecond)
// Keep trying until we're timed out or get a result/error
for {
select {
// Got a timeout! fail with a timeout error
case <-timeout:
return false, errors.New("timed out")
// Got a tick, we should check on checkSomething()
case <-ticker:
ok, err := checkSomething()
if err != nil {
// We may return, or ignore the error
return false, err
// checkSomething() done! let's return
} else if ok {
return true, nil
}
// checkSomething() isn't done yet, but it didn't fail either, let's try again
}
}
}