For loop 对于n秒后中断的循环

如何在执行后刚好经过一个1s后，使循环中断变得简单

var i int

for {
  i++
}

---

通过检查自启动以来经过的时间：

var i int
for start := time.Now(); time.Since(start) < time.Second; {
    i++
}

注意：如果循环体也执行通信操作（如发送或接收），则使用超时通道可能是唯一可行的选择！（您可以在相同的

选择中列出超时检查和循环的通信操作）

我们可以重写超时通道解决方案，使其不使用标签：

for stay, timeout := true, time.After(time.Second); stay; {
    i++
    select {
    case <-timeout:
        stay = false
    default:
    }
}

我们可以选择一个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
        }
    }
}

func keepCheckingSomething（）（布尔，错误）{
超时：=时间后（10*时间秒）
滴答器：=时间。滴答（500*时间。毫秒）
//继续尝试，直到超时或出现结果/错误
为了{
挑选{
//超时！失败，超时错误
案例
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
        }
    }
}