Golang：如何中断含time.Sleep的无限轮询并响应变量变更？

这个问题在Go开发里太常见了——time.Sleep是个「死心眼」的阻塞操作，一旦进入睡眠，除非时间到，否则根本没法中途打断，导致你的轮询逻辑没法及时响应UI触发的a值变化。下面给你几个实用的解决方案，都是Go生态里常用的中断轮询等待的思路：

方案1：用带中断信号的通道+select替代Sleep #

这是最直观也最常用的方案，核心思路是把不可中断的time.Sleep换成可被通道信号打断的select监听：

import (
    "time"
)

// 全局变量（或者根据你的架构封装成结构体字段）
var (
    a           bool
    interruptChan = make(chan struct{}, 1) // 带缓冲，避免UI发送信号时阻塞
)

// UI按钮点击触发的函数：修改a并发送中断信号
func onButtonClick(newVal bool) {
    a = newVal
    // 非阻塞发送信号，防止通道满时卡住UI线程
    select {
    case interruptChan <- struct{}{}:
    default:
    }
}

func poll() {
    for {
        // 先执行对应逻辑
        if a {
            device1()
        } else {
            sensor1()
        }

        // 等待10秒，或者收到中断信号就立即继续
        select {
        case <-interruptChan:
            // 收到UI的中断信号，直接进入下一轮检查a
        case <-time.After(time.Second * 10):
            // 正常超时，进入下一轮
        }
    }
}

为什么这么做？ #

• select会同时监听两个通道：一个是10秒后触发的超时通道（time.After返回的），另一个是UI触发的中断通道。
• 一旦UI修改a并发送信号，select会立刻选中中断通道的case，跳过剩余的等待时间，直接重新检查a的值。
• 给中断通道加缓冲是为了避免UI连续点击时，发送信号被阻塞（如果通道里已经有一个未处理的信号，再发送就会走default，不会卡UI）。

方案2：用Context实现可取消的等待 #

如果你的项目已经在使用context（比如服务端或复杂并发场景），用可取消的Context来实现中断会更贴合Go的并发设计：

import (
    "context"
    "time"
)

var (
    a         bool
    cancelFunc context.CancelFunc
    pollCtx    context.Context
)

// 初始化Context
func init() {
    pollCtx, cancelFunc = context.WithCancel(context.Background())
}

func onButtonClick(newVal bool) {
    a = newVal
    // 取消当前的等待，触发中断
    cancelFunc()
    // 重新创建新的Context，避免下一次等待被旧的取消信号影响
    pollCtx, cancelFunc = context.WithCancel(context.Background())
}

func poll() {
    for {
        if a {
            device1()
        } else {
            sensor1()
        }

        // 等待10秒，或者Context被取消
        select {
        case <-pollCtx.Done():
            // 收到取消信号，进入下一轮
        case <-time.After(time.Second * 10):
            // 正常超时
        }
    }
}

适用场景 #

• 适合需要和其他Context整合的场景（比如你的轮询逻辑需要响应服务的全局关闭信号）。
• 每次修改a时，通过cancelFunc()打断当前的等待，然后重建Context，确保下一轮等待不受影响。

方案3：用sync.Cond条件变量监听变量变化 #

如果需要精确监听a的变化（而不是单纯的中断等待），可以用Go的条件变量sync.Cond，同时要注意加锁保护变量的读写：

import (
    "sync"
    "time"
)

var (
    a    bool
    mu   sync.Mutex
    cond = sync.NewCond(&mu)
)

func onButtonClick(newVal bool) {
    mu.Lock()
    a = newVal
    mu.Unlock()
    // 唤醒正在等待的poll goroutine
    cond.Signal()
}

func poll() {
    for {
        mu.Lock()
        currentA := a
        mu.Unlock()

        if currentA {
            device1()
        } else {
            sensor1()
        }

        mu.Lock()
        // 等待10秒，或者被Signal唤醒
        deadline := time.Now().Add(time.Second * 10)
        cond.WaitUntil(deadline)
        mu.Unlock()
    }
}

注意事项 #

• 必须用锁保护a的读写，避免多goroutine下的竞态条件。
• WaitUntil会自动释放锁并等待，超时或被唤醒后会重新获取锁，确保变量访问的安全性。

额外提醒：避免竞态条件 #

如果a是被多个goroutine读写的（比如UI在一个goroutine，poll在另一个），直接读写bool变量会有竞态风险，建议用sync/atomic包来安全地读写：

import "sync/atomic"

var a atomic.Bool

func onButtonClick(newVal bool) {
    a.Store(newVal)
    // 发送中断信号...
}

func poll() {
    for {
        currentA := a.Load()
        if currentA {
            device1()
        } else {
            sensor1()
        }
        // 等待逻辑...
    }
}

内容的提问来源于stack exchange，提问作者Karthik