基于 golang 从零到一实现时间轮算法 (二)

Lzjusc20172023-11-05 13:22

Go实现单机版时间轮

上一章介绍了时间轮的相关概念，接下来我们会使用 golang 标准库的定时器工具 time ticker 结合环状数组的设计思路，实现一个单机版的单级时间轮。

首先我们先运行一下下面的源码，看一下如何使用。

https://github.com/xiaoxuxiansheng/timewheel

go 复制代码 
package main

import (
	"container/list"
	"fmt"
	"sync"
	"time"
)

type taskElement struct {
	task  func()
	pos   int
	cycle int
	key   string
}

type TimeWheel struct {
	sync.Once
	interval     time.Duration
	ticker       *time.Ticker
	stopc        chan struct{}
	addTaskCh    chan *taskElement
	removeTaskCh chan string
	slots        []*list.List
	curSlot      int
	keyToETask   map[string]*list.Element
}

func NewTimeWheel(slotNum int, interval time.Duration) *TimeWheel {
	if slotNum <= 0 {
		slotNum = 10
	}
	if interval <= 0 {
		interval = time.Second
	}

	t := TimeWheel{
		interval:     interval,
		ticker:       time.NewTicker(interval),
		stopc:        make(chan struct{}),
		keyToETask:   make(map[string]*list.Element),
		slots:        make([]*list.List, 0, slotNum),
		addTaskCh:    make(chan *taskElement),
		removeTaskCh: make(chan string),
	}
	for i := 0; i < slotNum; i++ {
		t.slots = append(t.slots, list.New())
	}
	go t.run()
	return &t
}

func (t *TimeWheel) Stop() {
	t.Do(func() {
		t.ticker.Stop()
		close(t.stopc)
	})
}

func (t *TimeWheel) AddTask(key string, task func(), executeAt time.Time) {
	pos, cycle := t.getPosAndCircle(executeAt)
	t.addTaskCh <- &taskElement{
		pos:   pos,
		cycle: cycle,
		task:  task,
		key:   key,
	}
}

func (t *TimeWheel) RemoveTask(key string) {
	t.removeTaskCh <- key
}

func (t *TimeWheel) run() {
	defer func() {
		if err := recover(); err != nil {
			// ...
		}
	}()

	for {
		select {
		case <-t.stopc:
			return
		case <-t.ticker.C:
			t.tick()
		case task := <-t.addTaskCh:
			t.addTask(task)
		case removeKey := <-t.removeTaskCh:
			t.removeTask(removeKey)
		}
	}
}

func (t *TimeWheel) tick() {
	list := t.slots[t.curSlot]
	defer t.circularIncr()
	t.execute(list)
}

func (t *TimeWheel) execute(l *list.List) {
	// 遍历每个 list
	for e := l.Front(); e != nil; {
		taskElement, _ := e.Value.(*taskElement)
		if taskElement.cycle > 0 {
			taskElement.cycle--
			e = e.Next()
			continue
		}

		// 执行任务
		go func() {
			defer func() {
				if err := recover(); err != nil {
					// ...
				}
			}()
			taskElement.task()
		}()

		// 执行任务后，从时间轮中删除
		next := e.Next()
		l.Remove(e)
		delete(t.keyToETask, taskElement.key)
		e = next
	}
}

func (t *TimeWheel) getPosAndCircle(executeAt time.Time) (int, int) {
	delay := int(time.Until(executeAt))
	cycle := delay / (len(t.slots) * int(t.interval))
	pos := (t.curSlot + delay/int(t.interval)) % len(t.slots)
	return pos, cycle
}

func (t *TimeWheel) addTask(task *taskElement) {
	list := t.slots[task.pos]
	if _, ok := t.keyToETask[task.key]; ok {
		t.removeTask(task.key)
	}
	eTask := list.PushBack(task)
	t.keyToETask[task.key] = eTask
}

func (t *TimeWheel) removeTask(key string) {
	eTask, ok := t.keyToETask[key]
	if !ok {
		return
	}
	delete(t.keyToETask, key)
	task, _ := eTask.Value.(*taskElement)
	_ = t.slots[task.pos].Remove(eTask)
}

func (t *TimeWheel) circularIncr() {
	t.curSlot = (t.curSlot + 1) % len(t.slots)
}

func main() {
	timeWheel := NewTimeWheel(10, 500*time.Millisecond)
	defer timeWheel.Stop()
	fmt.Println(time.Now())
	timeWheel.AddTask("test1", func() {
		fmt.Printf("test1, %v\n", time.Now())
	}, time.Now().Add(time.Second))
	timeWheel.AddTask("test2", func() {
		fmt.Printf("test2, %v\n", time.Now())
	}, time.Now().Add(5*time.Second))
	timeWheel.AddTask("test2", func() {
		fmt.Printf("test2, %v\n", time.Now())
	}, time.Now().Add(3*time.Second))

	<-time.After(10 * time.Second)
}

运行结果如下：

bash 复制代码 
2023-11-03 13:02:57.042834 +0800 CST m=+0.000173292
test1, 2023-11-03 13:02:58.043555 +0800 CST m=+1.000891376
test2, 2023-11-03 13:03:00.043567 +0800 CST m=+3.000897126

结果说明，首先添加test1任务定时1秒钟，test2任务定时5秒钟，但后续修改了test2定时为3秒钟，所以输出test1和test2的时间差为2秒钟。

数据结构

在对时间轮的类定义中，核心字段如下图所示：

go 复制代码 
type TimeWheel struct {
	sync.Once
	interval     time.Duration
	ticker       *time.Ticker
	stopc        chan struct{}
	addTaskCh    chan *taskElement
	removeTaskCh chan string
	slots        []*list.List
	curSlot      int
	keyToETask   map[string]*list.Element
}

在几个核心字段中：

  • slots------类似于时钟的表盘
  • curSlot------类似于时钟的指针
  • ticker 是使用 golang标准库的定时器工具，类似于驱动指针运转的齿轮

在创建时间轮实例时，会通过一个异步的常驻 goroutine 执行定时任务的检索、添加、删除等操作，并通过几个 channel 进行 goroutine 的执行逻辑和生命周期的控制：

  • stopc：用于停止 goroutine
  • addTaskCh：用于接收创建定时器指令
  • removeTaskCh：用于接收删除定时任务的指令

此处有几个技术细节需要提及：

首先 ：所谓环状数组指的是逻辑意义上的. 在实际的实现过程中，会通过一个定长数组结合循环遍历的方式，来实现这个逻辑意义上的"环状"性质.（有点类似于上一章提到的cycle）

其次：数组每一轮能表达的时间范围是固定的. 每当在添加添加一个定时任务时，需要根据其延迟的相对时长推算出其所处的 slot 位置，其中可能跨遍历轮次的情况，这时候需要额外通过定时任务中的 cycle 字段来记录这一信息，避免定时任务被提前执行.

最后：时间轮中一个 slot 可能需要挂载多笔定时任务，因此针对每个 slot，需要采用 golang 标准库 container/list 中实现的双向链表进行定时任务数据的存储.

定时任务

我们现在先看一笔任务的结构体介绍：

go 复制代码 
// 封装了一笔定时任务的明细信息
type taskElement struct {
    // 内聚了定时任务执行逻辑的闭包函数
    task  func()
    // 定时任务挂载在环状数组中的索引位置
    pos   int
    // 定时任务的延迟轮次. 指的是 curSlot 指针还要扫描过环状数组多少轮，才满足执行该任务的条件
    cycle int
    // 定时任务的唯一标识键
    key   string
}

  • task func(): 这是一个函数类型的字段，它引用了一个闭包。闭包是一种匿名函数，能够捕获到其外部作用域中的变量。在这里，task字段代表着定时任务的执行逻辑本身。当定时器触发时，这个闭包会被执行。这样设计可以让taskElement持有执行任务所需要进行的任何操作，使任务逻辑高度内聚和独立。

  • pos int: 该字段表示任务在环形数组（通常用于实现时间轮定时器）中的位置索引。环形数组是时间轮算法中的一种数据结构，用来表示时间的流逝。pos就是这个任务在这个环中的具体位置，当时间轮的指针指向这个位置时，就意味着这个taskElement代表的定时任务可能需要被执行。

  • cycle int: 在时间轮算法中，cycle用于表示任务延迟的轮次数。时间轮有一个当前指针curSlot，每当curSlot遍历一次完整的环形数组，所有任务的cycle值都会减1。一个任务的cycle值指示了curSlot需要再经过多少完整的遍历，该任务才会被执行。当cycle为0时，表示定时任务在当前轮次达到了执行条件。

  • key string: 这个字段是每个定时任务的唯一标识。key的存在允许任务在全局范围内被唯一标识和引用。这意味着你可以使用这个key来查询或者操作特定的定时任务，比如更新任务的延迟时间、取消任务或者是在任务被执行之前获取任务的状态。

综上所述，taskElement结构体将一个定时任务的执行逻辑、在时间轮中的位置、剩余的延迟轮次以及唯一标识符组合在一起，为定时任务的调度提供了必要的信息。

构造器

在创建时间轮的构造器函数中，需要传入两个入参：

  • slotNum：由使用方指定 slot 的个数，默认为 10
  • interval：由使用方指定每个 slot 对应的时间范围，默认为 1 秒

初始化时间轮实例的过程中，会完成定时器 ticker 以及各个 channel 的初始化，并针对数组 中的各个 slot 进行初始化，每个 slot 位置都需要填充一个 list.

每个时间轮实例都会异步调用 run 方法，启动一个常驻 goroutine 用于接收和处理定时任务.

go 复制代码 
// 创建单机版时间轮 slotNum------时间轮环状数组长度  interval------扫描时间间隔
func NewTimeWheel(slotNum int, interval time.Duration) *TimeWheel {
    // 环状数组长度默认为 10
    if slotNum <= 0 {
        slotNum = 10
    }
    // 扫描时间间隔默认为 1 秒
    if interval <= 0 {
        interval = time.Second
    }
    // 初始化时间轮实例
    t := TimeWheel{
        interval:     interval,
        ticker:       time.NewTicker(interval),
        stopc:        make(chan struct{}),
        keyToETask:   make(map[string]*list.Element),
        slots:        make([]*list.List, 0, slotNum),
        addTaskCh:    make(chan *taskElement),
        removeTaskCh: make(chan string),
    }
    for i := 0; i < slotNum; i++ {
        t.slots = append(t.slots, list.New())
    }
    
    // 异步启动时间轮常驻 goroutine
    go t.run()
    return &t
}

构造函数比较简单，由于异步run启动时间轮常驻 goroutine，所以我们现在看看run方法。

启动

时间轮运行的核心逻辑位于 timeWheel.run 方法中，该方法会通过 for 循环结合 select 多路复用的方式运行，属于 golang 中非常常见的异步编程风格.

goroutine 运行过程中需要从以下四类 channel 中接收不同的信号，并进行逻辑的分发处理：

  • stopc：停止时间轮，使得当前 goroutine 退出
  • ticker：接收到 ticker 的信号说明时间由往前推进了一个 interval，则需要批量检索并执行当前 slot 中的定时任务. 并推进指针 curSlot 往前偏移
  • addTaskCh：接收创建定时任务的指令
  • removeTaskCh：接收删除定时任务的指令

此处值得一提的是，后续不论是创建、删除还是检索定时任务，都是通过这个常驻 goroutine 完成的，因此在访问一些临界资源的时候，不需要加锁，因为不存在并发访问的情况

go 复制代码 
// 运行时间轮
func (t *TimeWheel) run() {
    defer func() {
        if err := recover(); err != nil {
            // ...
        }
    }()
    // 通过 for + select 的代码结构运行一个常驻 goroutine 是常规操作
    for {
        select {
        // 停止时间轮
        case <-t.stopc:
            return
        // 接收到定时信号
        case <-t.ticker.C:
            // 批量执行定时任务
            t.tick()
        // 接收创建定时任务的信号
        case task := <-t.addTaskCh:
            t.addTask(task)
        // 接收到删除定时任务的信号
        case removeKey := <-t.removeTaskCh:
            t.removeTask(removeKey)
        }
    }
}

停止

时间轮提供了一个 Stop 方法，用于手动停止时间轮，回收对应的 goroutine 和 ticker 资源.

停止时间轮的操作是通过关闭 stopc channel 完成的，由于 channel 不允许被反复关闭，因此这里通过 sync.Once 保证该逻辑只被调用一次.

go 复制代码 
// 停止时间轮
func (t *TimeWheel) Stop() {
    // 通过单例工具，保证 channel 只能被关闭一次，避免 panic
    t.Do(func() {
        // 定制定时器 ticker
        t.ticker.Stop()
        // 关闭定时器运行的 stopc
        close(t.stopc)
    })
}

创建任务

创建一笔定时任务的核心步骤如下：

  • 使用方往 addTaskCh 中投递定时任务，由常驻 goroutine 接收定时任务
  • 根据执行时间，推算出定时任务所处的 slot 位置以及需要延迟的轮次 cycle
  • 将定时任务包装成一个 list node，追加到对应 slot 位置的 list 尾部
  • 以定时任务唯一键为 key，list node 为 value，在 keyToETask map 中建立映射关系，方便后续删除任务时使用

我们首先看一下源码，然后再看相应的图解。

AddTask

go 复制代码 
// 添加定时任务到时间轮中
func (t *TimeWheel) AddTask(key string, task func(), executeAt time.Time) {
    // 根据执行时间推算得到定时任务从属的 slot 位置，以及需要延迟的轮次
    pos, cycle := t.getPosAndCircle(executeAt)
    // 将定时任务通过 channel 进行投递
    t.addTaskCh <- &taskElement{
        pos:   pos,
        cycle: cycle,
        task:  task,
        key:   key,
    }
}

pos, cycle := t.getPosAndCircle(executeAt): 这行代码调用了TimeWheel的另一个方法getPosAndCircle，传入期望执行的时间executeAt。这个方法计算出任务应该放置在时间轮的哪个槽位上（pos），以及在任务第一次执行前，时间轮需要转过多少完整的圈数（cycle）。

t.addTaskCh <- &taskElement{: 这是Go语言的通道（channel）操作。它创建了一个taskElement结构体实例，并通过TimeWheel中的addTaskCh通道发送出去。这种方式通常用于跨goroutine的安全通信，意味着AddTask方法将定时任务提交到另一个可能在不同goroutine中运行的执行上下文。

  • pos: pos,: 设置taskElement的pos字段，表示这个任务在时间轮的哪一个位置。
  • cycle: cycle,: 设置taskElement的cycle字段，表示任务在能被执行前时间轮需要转动多少圈。
  • task: task,: 将外部传入的任务闭包task赋给taskElement。
  • key: key,: 将任务的唯一标识符key赋给taskElement。

getPosAndCircle

go 复制代码 
// 根据执行时间推算得到定时任务从属的 slot 位置，以及需要延迟的轮次
func (t *TimeWheel) getPosAndCircle(executeAt time.Time) (int, int) {
    delay := int(time.Until(executeAt))
    // 定时任务的延迟轮次
    cycle := delay / (len(t.slots) * int(t.interval))
    // 定时任务从属的环状数组 index
    pos := (t.curSlot + delay/int(t.interval)) % len(t.slots)
    return pos, cycle
}

为了举例说明这个函数如何工作，我们需要设定一些参数：

  • 假设时间轮TimeWheel的slots有60个槽位，代表一分钟内的每一秒（len(t.slots) = 60）。
  • 时间轮的每个槽位对应1秒钟（t.interval = 1秒）。
  • 假设当前时间轮的指针curSlot在第0槽位上（t.curSlot = 0），这通常表示整点时刻。
  • 设定一个将来的时间点executeAt，假设这个时间点是从现在开始的第62秒后。这意味着我们希望在1分钟2秒后执行任务（delay = 62秒）。
bash 复制代码 
// 从现在开始到执行时间的延迟时间（秒）
delay := int(time.Until(executeAt))  // delay = 62

// 计算定时任务需要经过的完整时间轮循环数
cycle := delay / (len(t.slots) * int(t.interval))  
// cycle = 62 / (60 * 1) = 1.033，向下取整为 1

// 计算定时任务应该位于的槽位（数组index）
pos := (t.curSlot + delay/int(t.interval)) % len(t.slots)
// pos = (0 + 62/1) % 60 = 62 % 60 = 2

所以，函数getPosAndCircle将会返回(2, 1)：

假设时间轮有5个槽位，每个槽位间隔为1秒，并且当前槽位（curSlot）为0。我们需要计算延迟0到11秒的任务对应的槽位（pos）和轮次（cycle）。

  • 延迟0秒：槽位0，轮次0
  • 延迟1秒：槽位1，轮次0
  • 延迟2秒：槽位2，轮次0
  • 延迟3秒：槽位3，轮次0
  • 延迟4秒：槽位4，轮次0
  • 延迟5秒：槽位0，轮次1
  • 延迟6秒：槽位1，轮次1
  • 延迟7秒：槽位2，轮次1
  • 延迟8秒：槽位3，轮次1
  • 延迟9秒：槽位4，轮次1
  • 延迟10秒：槽位0，轮次2
  • 延迟11秒：槽位1，轮次2

现在看一下执行过程。

addTask

go 复制代码 
// 常驻 goroutine 接收到创建定时任务后的处理逻辑
func (t *TimeWheel) addTask(task *taskElement) {
    // 获取到定时任务从属的环状数组 index 以及对应的 list
    list := t.slots[task.pos]
    // 倘若定时任务 key 之前已存在，则需要先删除定时任务
    if _, ok := t.keyToETask[task.key]; ok {
        t.removeTask(task.key)
    }
    // 将定时任务追加到 list 尾部
    eTask := list.PushBack(task)
    // 建立定时任务 key 到将定时任务所处的节点
    t.keyToETask[task.key] = eTask
}

倘若定时任务 key 之前已存在，则需要先删除定时任务，然后重新添加到末尾。这张图很详细的说明执行的过程了。

删除任务

删除一笔定时任务的核心步骤如下：

  • 使用方往 removeTaskCh 中投递删除任务的 key，由常驻 goroutine 接收处理
  • 从 keyToETask map 中，找到该任务对应的 list node
  • 从 keyToETask map 中移除该组 kv 对
  • 从对应 slot 的 list 中移除该 list node
go 复制代码 
// 删除定时任务，投递信号
func (t *TimeWheel) RemoveTask(key string) {
    t.removeTaskCh <- key
}
// 时间轮常驻 goroutine 接收到删除任务信号后，执行的删除任务逻辑
func (t *TimeWheel) removeTask(key string) {
    eTask, ok := t.keyToETask[key]
    if !ok {
        return
    }
    // 将定时任务节点从映射 map 中移除
    delete(t.keyToETask, key)
    // 获取到定时任务节点后，将其从 list 中移除
    task, _ := eTask.Value.(*taskElement)
    _ = t.slots[task.pos].Remove(eTask)
}

执行定时任务

最后来捋一下最核心的链路------检索并批量执行定时任务的流程.

首先，每当接收到 ticker 信号时，会根据当前的 curSlot 指针，获取到对应 slot 位置挂载的定时任务 list，调用 execute 方法执行其中的定时任务，最后通过 circularIncr 方法推进 curSlot 指针向前移动。

go 复制代码 
// 常驻 goroutine 每次接收到定时信号后用于执行定时任务的逻辑
func (t *TimeWheel) tick() {
    // 根据 curSlot 获取到当前所处的环状数组索引位置，取出对应的 list
    list := t.slots[t.curSlot]
     // 在方法返回前，推进 curSlot 指针的位置，进行环状遍历
    defer t.circularIncr()
    // 批量处理满足执行条件的定时任务
    t.execute(list)
}

在 execute 方法中，会对 list 中的定时任务进行遍历：

  • 对于 cycle > 0 的定时任务，说明当前还未达到执行条件，需要将其 cycle 值减 1，留待后续轮次再处理
  • 对于 cycle = 0 的定时任务，开启一个 goroutine ，执行其中的闭包函数 task，并将其从 list 和 map 中移除
go 复制代码 
// 执行定时任务，每次处理一个 list
func (t *TimeWheel) execute(l *list.List) {
    // 遍历 list
    for e := l.Front(); e != nil; {
        // 获取到每个节点对应的定时任务信息
        taskElement, _ := e.Value.(*taskElement)
        // 倘若任务还存在延迟轮次，则只对 cycle 计数器进行扣减，本轮不作任务的执行
        if taskElement.cycle > 0 {
            taskElement.cycle--
            e = e.Next()
            continue
        }
        // 当前节点对应定时任务已达成执行条件，开启一个 goroutine 负责执行任务
        go func() {
            defer func() {
                if err := recover(); err != nil {
                    // ...
                }
            }()
            taskElement.task()
        }()


        // 任务已执行，需要把对应的任务节点从 list 中删除
        next := e.Next()
        l.Remove(e)
        // 把任务 key 从映射 map 中删除
        delete(t.keyToETask, taskElement.key)
        e = next
    }
}

// 每次 tick 后需要推进 curSlot 指针的位置，slots 在逻辑意义上是环状数组，所以在到达尾部时需要从新回到头部 
func (t *TimeWheel) circularIncr() {
    t.curSlot = (t.curSlot + 1) % len(t.slots)
}

总结

看了小徐先生的推文跟B站视频收获很多，也期待后续跟着大佬继续学习。

参考

https://zhuanlan.zhihu.com/p/658079556

https://blog.csdn.net/YouMing_Li/article/details/134089794

相关推荐
Ocean☾几秒前
前端基础-html-注册界面
前端·算法·html
疯狂的程需猿5 分钟前
一个百度、必应搜索引擎图片获取下载的工具包
golang·图搜索
顶呱呱程序8 分钟前
2-143 基于matlab-GUI的脉冲响应不变法实现音频滤波功能
算法·matlab·音视频·matlab-gui·音频滤波·脉冲响应不变法
&岁月不待人&15 分钟前
Kotlin by lazy和lateinit的使用及区别
android·开发语言·kotlin
StayInLove18 分钟前
G1垃圾回收器日志详解
java·开发语言
无尽的大道26 分钟前
Java字符串深度解析：String的实现、常量池与性能优化
java·开发语言·性能优化
爱吃生蚝的于勒30 分钟前
深入学习指针（5）！！！！！！！！！！！！！！！
c语言·开发语言·数据结构·学习·计算机网络·算法
羊小猪~~33 分钟前
数据结构C语言描述2(图文结合)--有头单链表，无头单链表(两种方法)，链表反转、有序链表构建、排序等操作，考研可看
c语言·数据结构·c++·考研·算法·链表·visual studio
binishuaio39 分钟前
Java 第11天 (git版本控制器基础用法)
java·开发语言·git
zz.YE41 分钟前
【Java SE】StringBuffer
java·开发语言
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play