如何实现Go语言Ticker在任务运行时丢弃重复tick？

没问题，我来帮你搞定这个需求！你的核心诉求是：当周期性任务正在执行时，即使Ticker的时间间隔到了，也不要重复执行任务，直接丢弃这些触发信号。

先说说你原代码的问题：当任务执行时间（比如你代码里的4秒）超过Ticker的间隔（3秒）时，ticker.C通道会缓存多个未处理的tick事件。等当前任务结束后，这些缓存的tick会被依次处理，导致连续执行任务，这显然不是你想要的“丢弃”效果。

下面给你两种实用的解决方案，你可以根据场景选择：

方案一：用忙标志+异步goroutine执行任务 #

这种方法通过一个原子布尔变量标记当前是否有任务在运行，收到tick时如果任务忙就直接跳过；否则启动goroutine异步执行任务，避免阻塞主循环，同时保证同一时间只有一个任务在运行。

package main

import (
	"fmt"
	"sync/atomic"
	"time"
)

func main() {
	ticker := time.NewTicker(3 * time.Second)
	defer ticker.Stop()

	// 用原子变量保证并发安全，标记当前是否有任务在运行
	var isRunning atomic.Bool

	for {
		select {
		case t := <-ticker.C:
			// 如果任务正在运行，直接跳过这次tick
			if isRunning.Load() {
				fmt.Println("任务还在执行，跳过本次触发：", t)
				continue
			}

			// 标记任务开始执行
			isRunning.Store(true)
			// 启动goroutine执行任务，避免阻塞主循环
			go func(tickTime time.Time) {
				defer isRunning.Store(false) // 任务结束后重置标志

				fmt.Println("开始执行任务：", tickTime)
				// 模拟任务执行时间，偶数次耗时4秒（超过Ticker间隔）
				if tickTime.Unix()%2 == 0 {
					time.Sleep(4 * time.Second)
				}
				fmt.Println("任务执行完成：", time.Now())
			}(t)
		}
	}
}

方案二：处理任务前清空通道积压的tick #

这种方法会在每次准备处理任务前，把ticker.C中所有积压的tick都读出来，只保留最新的那一个。这样即使任务耗时很久，积压的旧tick都会被丢弃，只处理最新的一次触发。

package main

import (
	"fmt"
	"time"
)

func main() {
	ticker := time.NewTicker(3 * time.Second)
	defer ticker.Stop()

	for {
		var latestTick time.Time

		// 先读取所有积压的tick，只留下最后一个
		select {
		case latestTick = <-ticker.C:
			// 循环检查是否还有更多未处理的tick
			for {
				select {
				case t := <-ticker.C:
					latestTick = t
				default:
					// 没有更多tick了，跳出循环去处理任务
					goto processTask
				}
			}
		default:
			// 当前没有tick，等待下一次触发
			latestTick = <-ticker.C
		}

	processTask:
		fmt.Println("处理最新触发：", latestTick)
		// 模拟任务执行时间
		if latestTick.Unix()%2 == 0 {
			time.Sleep(4 * time.Second)
		}
		fmt.Println("处理完成：", time.Now())
	}
}

两种方案的适用场景 #

• 方案一：适合严格禁止任务并发执行的场景，所有在任务运行期间到来的tick都会被直接丢弃，直到当前任务结束才会响应下一次触发。
• 方案二：适合希望任务结束后只处理最新的一次触发的场景，旧的积压tick会被丢弃，但不会完全忽略所有在任务运行期间的触发。

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