在并发编程中，尤其是在构建事件驱动系统时，常常需要一个核心的事件循环来调度和执行各种任务。一个常见的需求是，某些任务（我们称之为“当前tick”任务）可能由多个并发调用方触发，但我们希望在处理下一个主事件（“下一tick”任务）之前，确保所有已触发的“当前tick”任务都已完成。
传统的解决方案，如使用互斥锁（mutex）并不断检查任务计数，会导致CPU的忙等待（busy-waiting），严重浪费计算资源。而使用 time.Sleep 进行周期性检查，虽然避免了忙等待，但会引入不可接受的延迟，影响系统的响应性。原始问题中尝试使用 reflect.Value 和手动维护线程计数，并结合互斥量进行保护，但这种方式不仅复杂，而且难以高效地解决低延迟等待的问题。核心挑战在于，如何在不阻塞主循环、不浪费CPU、且保持低延迟的前提下，优雅地等待一组动态生成的并发任务完成。
Go语言的通道（channels）是实现并发通信和同步的强大原语，它们天生适合构建事件循环。通过将任务封装成函数并通过通道发送，我们可以实现任务的非阻塞提交和有序处理。这种方式利用了Go运行时（runtime）的调度能力，避免了手动管理锁和条件变量的复杂性，提供了一种更简洁、高效且符合Go并发哲学的设计。
我们定义一个 EventLoop 结构体来管理不同类型的任务通道：
package eventloop
type EventLoop struct {
nextFunc chan func() // 用于接收“下一tick”任务的通道
curFunc chan func() // 用于接收“当前tick”任务的通道
}事件循环的初始化与任务提交：
func NewEventLoop() *EventLoop {
el := &EventLoop{
// 通道容量可根据实际并发量和缓冲需求调整
make(chan func(), 3), // 示例容量为3
make(chan func(), 3), // 示例容量为3
}
go eventLoop(el) // 在单独的 Goroutine 中启动事件循环
return el
}
// NextTick 提交一个“下一tick”任务
func (el *EventLoop) NextTick(f func()) {
el.nextFunc <- f
}
// CurrentTick 提交一个“当前tick”任务
func (el *EventLoop) CurrentTick(f func()) {
el.curFunc <- f
}
// Quit 用于优雅地关闭事件循环
func (el *EventLoop) Quit() {
close(el.nextFunc) // 关闭 nextFunc 通道，通知事件循环退出
}eventLoop 函数是整个事件循环的核心，它在一个无限循环中监听并处理任务：
func eventLoop(el *EventLoop) {
for {
// 1. 等待并执行下一个“下一tick”任务
f, ok := <-el.nextFunc
if !ok {
// 如果 nextFunc 通道被关闭，表示事件循环需要退出
return
}
f() // 执行“下一tick”任务
// 2. 清空并执行所有已提交的“当前tick”任务
drain:
for {
select {
case f := <-el.curFunc:
// 从 curFunc 通道中取出任务并执行
f()
default:
// 如果 curFunc 通道当前为空，则跳出循环
// 确保在处理下一个 nextFunc 任务之前，所有 curFunc 任务都已处理
break drain
}
}
}
}package eventloop
import (
"fmt"
"time"
)
// EventLoop 结构体定义，包含两个用于任务调度的通道
type EventLoop struct {
nextFunc chan func()
curFunc chan func()
}
// NewEventLoop 创建并启动一个新的 EventLoop 实例
func NewEventLoop() *EventLoop {
el := &EventLoop{
// 调整通道容量以适应并发需求和缓冲策略
nextFunc: make(chan func(), 5), // 示例容量
curFunc: make(chan func(), 5), // 示例容量
}
go eventLoop(el) // 在一个独立的 Goroutine 中运行事件循环
return el
}
// NextTick 提交一个“下一tick”任务。这些任务将按顺序执行。
func (el *EventLoop) NextTick(f func()) {
el.nextFunc <- f
}
// CurrentTick 提交一个“当前tick”任务。这些任务将在当前 NextTick 任务完成后，
// 且在下一个 NextTick 任务开始前被清空并执行。
func (el *EventLoop) CurrentTick(f func()) {
el.curFunc <- f
}
// Quit 用于通知事件循环优雅地停止。
func (el *EventLoop) Quit() {
close(el.nextFunc) // 关闭 nextFunc 通道，eventLoop 将检测到并退出
}
// eventLoop 是 EventLoop 的核心执行函数，在一个独立的 Goroutine 中运行。
func eventLoop(el *EventLoop) {
fmt.Println("EventLoop started.")
for {
// 1. 等待并执行下一个“下一tick”任务
f, ok := <-el.nextFunc
if !ok {
// nextFunc 通道已关闭，退出循环
fmt.Println("EventLoop nextFunc channel closed. Exiting.")
return
}
fmt.Println("--- Executing NextTick task ---")
f() // 执行 NextTick 任务
// 2. 清空并执行所有已提交的“当前tick”任务
// 这是一个非阻塞的循环，会处理所有当前可用的 curFunc 任务
drain:
for {
select {
case f := <-el.curFunc:
fmt.Println(" --- Executing CurrentTick task ---")
f() // 执行 CurrentTick 任务
default:
// curFunc 通道当前为空，跳出 drain 循环
fmt.Println(" --- All CurrentTick tasks drained. ---")
break drain
}
}
}
}
// 示例用法
func main() {
el := NewEventLoop()
// 提交一个 NextTick 任务
el.NextTick(func() {
fmt.Println("NextTick 1: Processing main logic.")
// 在 NextTick 1 执行期间，提交一些 CurrentTick 任务
el.CurrentTick(func() {
fmt.Println(" CurrentTick A: Background task 1.")
time.Sleep(50 * time.Millisecond) // 模拟耗时操作
})
el.CurrentTick(func() {
fmt.Println(" CurrentTick B: Background task 2.")
time.Sleep(30 * time.Millisecond)
})
})
// 提交另一个 NextTick 任务
el.NextTick(func() {
fmt.Println("NextTick 2: Another main logic.")
el.CurrentTick(func() {
fmt.Println(" CurrentTick C: Another background task.")
time.Sleep(20 * time.Millisecond)
})
})
// 再提交一个 CurrentTick 任务，它会在 NextTick 2 之后被处理
el.CurrentTick(func() {
fmt.Println(" CurrentTick D: Task after NextTick 2.")
time.Sleep(10 * time.Millisecond)
})
// 模拟程序运行一段时间
time.Sleep(500 * time.Millisecond)
// 优雅关闭事件循环
el.Quit()
// 等待事件循环完全退出 (在实际应用中可能需要更健壮的等待机制，如 sync.WaitGroup)
time.Sleep(100 * time.Millisecond)
fmt.Println("Main program finished.")
}运行上述 main 函数，你将看到如下输出模式：
本教程展示了如何利用Go语言的通道（channels）构建一个高效、低延迟的事件循环。通过将任务分为“下一tick”和“当前tick”两种类型，并巧妙地利用通道的阻塞和非阻塞特性，我们实现了在处理下一个主事件之前，确保所有相关联的“当前tick”任务已完成的目标。这种方法避免了忙等待和高延迟休眠的弊端，提供了一个简洁、健壮且符合Go并发哲学的解决方案，是构建高性能并发系统的理想选择。
以上就是Go 并发模式：构建高效低延迟的事件循环与任务等待机制的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
956
收藏
