go-zero 如何应对海量定时/延迟任务

一个系统中存在着大量的调度任务,同时调度任务存在时间的滞后性,而大量的调度任务如果每一个都使用自己的调度器来管理任务的生命周期的话,浪费cpu的资源而且很低效。

本文来介绍 go-zero 中 延迟操作,它可能让开发者调度多个任务时,只需关注具体的业务执行函数和执行时间「立即或者延迟」。而 延迟操作,通常可以采用两个方案:

Timer:定时器维护一个优先队列,到时间点执行,然后把需要执行的 task 存储在 map 中collection 中的 timingWheel ,维护一个存放任务组的数组,每一个槽都维护一个存储task的双向链表。开始执行时,计时器每隔指定时间执行一个槽里面的tasks。

方案2把维护task从 优先队列 O(nlog(n)) 降到 双向链表 O(1),而执行task也只要轮询一个时间点的tasks O(N),不需要像优先队列,放入和删除元素 O(nlog(n))

我们先看看 go-zero 中自己对 timingWheel 的使用 :

cache 中的 timingWheel

首先我们先来在 collectioncache 中关于 timingWheel 的使用:

timingWheel, err := NewTimingWheel(time.Second, slots, func(k, v interface{}) {
 key, ok := k.(string)
 if !ok {
  return
 }
 cache.Del(key)
})
if err != nil {
 return nil, err
}

cache.timingWheel = timingWheel

这是 cache 初始化中也同时初始化 timingWheel 做key的过期处理,参数依次代表:

  • interval:时间划分刻度
  • numSlots:时间槽
  • execute:时间点执行函数

cache 中执行函数则是 删除过期key,而这个过期则由 timingWheel 来控制推进时间。

接下来,就通过 cachetimingWheel 的使用来认识。

初始化

// 真正做初始化
func newTimingWheelWithClock(interval time.Duration, numSlots int, execute Execute, ticker timex.Ticker) (
	*TimingWheel, error) {
	tw := &TimingWheel{
		interval:   interval,           // 单个时间格时间间隔
		ticker:    ticker,            // 定时器,做时间推动,以interval为单位推进
		slots:     make([]*list.List, numSlots), // 时间轮
		timers:    NewSafeMap(),         // 存储task{key, value}的map [执行execute所需要的参数]
		tickedPos:   numSlots - 1,         // at previous virtual circle
		execute:    execute,           // 执行函数
		numSlots:   numSlots,           // 初始化 slots num
		setChannel:  make(chan timingEntry),    // 以下几个channel是做task传递的
		moveChannel:  make(chan baseEntry),
		removeChannel: make(chan interface{}),
		drainChannel: make(chan func(key, value interface{})),
		stopChannel:  make(chan lang.PlaceholderType),
	}
	// 把 slot 中存储的 list 全部准备好
	tw.initSlots()
	// 开启异步协程,使用 channel 来做task通信和传递
	go tw.run()

	return tw, nil
}

以上比较直观展示 timingWheel 的 “时间轮”,后面会围绕这张图解释其中推进的细节。

go tw.run() 开一个协程做时间推动:

func (tw *TimingWheel) run() {
	for {
		select {
   // 定时器做时间推动 -> scanAndRunTasks()
		case <-tw.ticker.Chan():
			tw.onTick()
   // add task 会往 setChannel 输入task
		case task := <-tw.setChannel:
			tw.setTask(&task)
		...
		}
	}
}

可以看出,在初始化的时候就开始了 timer 执行,并以internal时间段转动,然后底层不停的获取来自 slot 中的 list 的task,交给 execute 执行。

Task Operation

紧接着就是设置 cache key

func (c *Cache) Set(key string, value interface{}) {
	c.lock.Lock()
	_, ok := c.data[key]
	c.data[key] = value
	c.lruCache.add(key)
	c.lock.Unlock()

	expiry := c.unstableExpiry.AroundDuration(c.expire)
	if ok {
		c.timingWheel.MoveTimer(key, expiry)
	} else {
		c.timingWheel.SetTimer(key, value, expiry)
	}
}

先看在 data map 中有没有存在这个key存在,则更新 expire -> MoveTimer()第一次设置key -> SetTimer()

所以对于 timingWheel 的使用上就清晰了,开发者根据需求可以 add 或是 update

同时我们跟源码进去会发现:SetTimer() MoveTimer() 都是将task输送到channel,由 run() 中开启的协程不断取出 channel 的task操作。

SetTimer() -> setTask()

not exist task:getPostion -> pushBack to list -> setPositionexist task:get from timers -> moveTask()

MoveTimer() -> moveTask()

由上面的调用链,有一个都会调用的函数:moveTask()

func (tw *TimingWheel) moveTask(task baseEntry) {
	// timers: Map => 通过key获取 [positionEntry「pos, task」]
	val, ok := tw.timers.Get(task.key)
	if !ok {
		return
	}

	timer := val.(*positionEntry)
 	// {delay < interval} => 延迟时间比一个时间格间隔还小,没有更小的刻度,说明任务应该立即执行
	if task.delay < tw.interval {
		threading.GoSafe(func() {
			tw.execute(timer.item.key, timer.item.value)
		})
		return
	}
	// 如果 > interval,则通过 延迟时间delay 计算其出时间轮中的 new pos, circle
	pos, circle := tw.getPositionAndCircle(task.delay)
	if pos >= timer.pos {
		timer.item.circle = circle
        // 记录前后的移动offset。为了后面过程重新入队
		timer.item.diff = pos - timer.pos
	} else if circle > 0 {
		// 转移到下一层,将 circle 转换为 diff 一部分
		circle--
		timer.item.circle = circle
		// 因为是一个数组,要加上 numSlots [也就是相当于要走到下一层]
		timer.item.diff = tw.numSlots + pos - timer.pos
	} else {
		// 如果 offset 提前了,此时 task 也还在第一层
		// 标记删除老的 task,并重新入队,等待被执行
		timer.item.removed = true
		newItem := &timingEntry{
			baseEntry: task,
			value:   timer.item.value,
		}
		tw.slots[pos].PushBack(newItem)
		tw.setTimerPosition(pos, newItem)
	}
}

以上过程有以下几种情况:

delay < internal:因为 < 单个时间精度,表示这个任务已经过期,需要马上执行针对改变的 delaynew >= old<newPos, newCircle, diff>newCircle > 0:计算diff,并将 circle 转换为 下一层,故diff + numslots如果只是单纯延迟时间缩短,则将老的task标记删除,重新加入list,等待下一轮loop被execute

Execute

之前在初始化中,run() 中定时器的不断推进,推进的过程主要就是把 list中的 task 传给执行的 execute func。我们从定时器的执行开始看:

// 定时器 「每隔 internal 会执行一次」
func (tw *TimingWheel) onTick() {
    // 每次执行更新一下当前执行 tick 位置
	tw.tickedPos = (tw.tickedPos + 1) % tw.numSlots
    // 获取此时 tick位置 中的存储task的双向链表
	l := tw.slots[tw.tickedPos]
	tw.scanAndRunTasks(l)
}

紧接着是如何去执行 execute

func (tw *TimingWheel) scanAndRunTasks(l *list.List) {
	// 存储目前需要执行的task{key, value} [execute所需要的参数,依次传递给execute执行]
	var tasks []timingTask

	for e := l.Front(); e != nil; {
		task := e.Value.(*timingEntry)
        // 标记删除,在 scan 中做真正的删除 「删除map的data」
		if task.removed {
			next := e.Next()
			l.Remove(e)
			tw.timers.Del(task.key)
			e = next
			continue
		} else if task.circle > 0 {
			// 当前执行点已经过期,但是同时不在第一层,所以当前层即然已经完成了,就会降到下一层
            // 但是并没有修改 pos
			task.circle--
			e = e.Next()
			continue
		} else if task.diff > 0 {
			// 因为之前已经标注了diff,需要再进入队列
			next := e.Next()
			l.Remove(e)
			pos := (tw.tickedPos + task.diff) % tw.numSlots
			tw.slots[pos].PushBack(task)
			tw.setTimerPosition(pos, task)
			task.diff = 0
			e = next
			continue
		}
		// 以上的情况都是不能执行的情况,能够执行的会被加入tasks中
		tasks = append(tasks, timingTask{
			key:  task.key,
			value: task.value,
		})
		next := e.Next()
		l.Remove(e)
		tw.timers.Del(task.key)
		e = next
	}
	// for range tasks,然后把每个 task->execute 执行即可
	tw.runTasks(tasks)
}

具体的分支情况在注释中说明了,在看的时候可以和前面的 moveTask() 结合起来,其中 circle 下降,diff 的计算是关联两个函数的重点。

至于 diff 计算就涉及到 pos, circle 的计算:

// interval: 4min, d: 60min, numSlots: 16, tickedPos = 15
// step = 15, pos = 14, circle = 0
func (tw *TimingWheel) getPositionAndCircle(d time.Duration) (pos int, circle int) {
	steps := int(d / tw.interval)
	pos = (tw.tickedPos + steps) % tw.numSlots
	circle = (steps - 1) / tw.numSlots
	return
}

上面的过程可以简化成下面:

steps = d / interval
pos = step % numSlots - 1
circle = (step - 1) / numSlots

总结

timingWheel 靠定时器推动,时间前进的同时会取出当前时间格中 list「双向链表」的task,传递到 execute 中执行。因为是是靠 internal 固定时间刻度推进,可能就会出现:一个 60s 的task,internal = 1s,这样就会空跑59次loop。

而在扩展时间上,采取 circle 分层,这样就可以不断复用原有的 numSlots ,因为定时器在不断 loop,而执行可以把上层的 slot 下降到下层,在不断 loop 中就可以执行到上层的task。这样的设计可以在不创造额外的数据结构,突破长时间的限制。

同时在 go-zero 中还有很多实用的组件工具,用好工具对于提升服务性能和开发效率都有很大的帮助,希望本篇文章能给大家带来一些收获。

项目地址

https://github.com/tal-tech/go-zero

好未来技术

到此这篇关于go-zero 如何应对海量定时/延迟任务的文章就介绍到这了,更多相关go-zero定时/延迟任务内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Django配置celery(非djcelery)执行异步任务和定时任务

    所有演示均基于Django2.0 celery是一个基于python开发的简单.灵活且可靠的分布式任务队列框架,支持使用任务队列的方式在分布式的机器/进程/线程上执行任务调度.采用典型的生产者-消费者模型,主要由三部分组成: 消息队列broker:broker实际上就是一个MQ队列服务,可以使用redis.rabbitmq等作为broker 处理任务的消费者workers:broker通知worker队列中有任务,worker去队列中取出任务执行,每一个worker就是一个进程 存储结果的bac

  • django+xadmin+djcelery实现后台管理定时任务

    继上一篇中间表的数据是动态的,图表展示的数据才比较准确.这里用到一个新的模块Djcelery,安装配置步骤如下: 1.安装 redis==2.10.6 celery==3.1.23 django-celery==3.1.17 flower==0.9.2 supervisor==3.3.4 flower用于监控定时任务,supervisor管理进程,可选 2.配置 settings.py中添加以下几行: #最顶头加上 from __future__ import absolute_import #

  • Golang中定时器的陷阱详解

    前言 在业务中,我们经常需要基于定时任务来触发来实现各种功能.比如TTL会话管理.锁.定时任务(闹钟)或更复杂的状态切换等等.百纳网主要给大家介绍了关于Golang定时器陷阱的相关内容,所谓陷阱,就是它不是你认为的那样,这种认知误差可能让你的软件留下隐藏Bug.刚好Timer就有3个陷阱,我们会讲 1)Reset的陷阱和 2)通道的陷阱, 3)Stop的陷阱与Reset的陷阱类似,自己探索吧. 下面话不多说了,来一起看看详细的介绍吧 Reset的陷阱在哪 Timer.Reset()函数的返回值是

  • go-zero 如何应对海量定时/延迟任务

    一个系统中存在着大量的调度任务,同时调度任务存在时间的滞后性,而大量的调度任务如果每一个都使用自己的调度器来管理任务的生命周期的话,浪费cpu的资源而且很低效. 本文来介绍 go-zero 中 延迟操作,它可能让开发者调度多个任务时,只需关注具体的业务执行函数和执行时间「立即或者延迟」.而 延迟操作,通常可以采用两个方案: Timer:定时器维护一个优先队列,到时间点执行,然后把需要执行的 task 存储在 map 中collection 中的 timingWheel ,维护一个存放任务组的数组

  • go-zero 应对海量定时/延迟任务的技巧

    一个系统中存在着大量的调度任务,同时调度任务存在时间的滞后性,而大量的调度任务如果每一个都使用自己的调度器来管理任务的生命周期的话,浪费cpu的资源而且很低效. 本文来介绍 go-zero 中 延迟操作,它可能让开发者调度多个任务时,只需关注具体的业务执行函数和执行时间「立即或者延迟」.而 延迟操作,通常可以采用两个方案: Timer:定时器维护一个优先队列,到时间点执行,然后把需要执行的 task 存储在 map 中collection 中的 timingWheel ,维护一个存放任务组的数组

  • 建立在Tablestore的Wifi设备监管系统架构实现

    Wifi设备监管 公司通过监管系统维护Wifi设备属性.采集Wifi设备监控数据.当需要Wifi设备上.下线时,通过监管系统操作完成设备的添加.下线,同时可通过系统修改.增加设备属性信息,如:设备mac地址.设备型号.设备地理位置等.设备上线后,会定期向系统推送监控数据,从而完成设备监控数据的采集.采集数据包含:cpu.内存.连接数.Wan口流量与流速.2.4G与5G模块的信道数据等. 通过分析监控数据指标.分析设备运行状态,动态将问题设备的运行状态修改为:预警.报警.借助系统,网络部门可以快速

  • 浅谈Scrapy框架普通反爬虫机制的应对策略

    简单低级的爬虫速度快,伪装度低,如果没有反爬机制,它们可以很快的抓取大量数据,甚至因为请求过多,造成服务器不能正常工作.而伪装度高的爬虫爬取速度慢,对服务器造成的负担也相对较小. 爬虫与反爬虫,这相爱相杀的一对,简直可以写出一部壮观的斗争史.而在大数据时代,数据就是金钱,很多企业都为自己的网站运用了反爬虫机制,防止网页上的数据被爬虫爬走.然而,如果反爬机制过于严格,可能会误伤到真正的用户请求;如果既要和爬虫死磕,又要保证很低的误伤率,那么又会加大研发的成本. 简单低级的爬虫速度快,伪装度低,如果

  • 如何实现定时推送的具体方案

    详细内容 详细内容大概分为4个部分,1.应用场景 2.遇到问题 3.设计 4.实现 5.运行效果 1.应用场景 需要定时推送数据,且轻量化的实现. 2.遇到问题 如果启动一个定时器去定时轮询 (1)轮询效率比较低 (2)每次扫库,已经被执行过记录,仍然会被扫描(只是不会出现在结果集中),会做重复工作 (3)时效性不够好,如果每小时轮询一次,最差的情况下会有时间误差 如何利用"延时消息",对于每个任务只触发一次,保证效率的同时保证实时性,是今天要讨论的问题. 3.设计 高效延时消息,包含

  • 基于rabbitmq延迟插件实现分布式延迟任务

    目录 一.延迟任务的使用场景 二.组件安装 三.RabbitMQ延迟队列插件的延迟队列实现 1.基本原理 2.核心组件开发走起 之前给大家介绍过SpringBoot集成Redisson实现延迟队列的场景分析,今天介绍下基于rabbitmq延迟插件rabbitmq_delayed_message_exchange实现延迟任务. 一.延迟任务的使用场景 1.下单成功,30分钟未支付.支付超时,自动取消订单 2.订单签收,签收后7天未进行评价.订单超时未评价,系统默认好评 3.下单成功,商家5分钟未接

  • windows下定时利用bat脚本实现ftp上传下载

    前言: 工作中可能会遇到以下情况,利用windows作为中转,来实现两台linux服务器的文件传输. 实现步骤: 1.FTP上传和下载的bat脚本. 脚本分为两部分:可执行bat脚本和ftp命令文件: 可执行bat脚本: @echo off ftp -s:D:\ftp\ftp.txt ftp命令ftp.txt: open 192.168.1.166 ftp-user passwd prompt off lcd D:\ftp cd /home/myftp mget * close open 10.

  • 如何利用DOS批处理实现定时关机操作详解

    一.批处理释义: 批处理(Batch),也称为批处理脚本.它是对某对象进行批量的处理,通常被认为是一种简化的脚本语言,应用于DOS和Windows系统中.批处理文件的扩展名为bat. 目前比较常见的批处理包含两类:DOS批处理和PS批处理.PS批处理是基于强大的图片编辑软件Photoshop的,用来批量处理图片的脚本:而DOS批处理则是基于DOS命令的,用来自动地批量地执行DOS命令以实现特定操作的脚本. 二.编写批处理文件: (1)新建一个文本文件,在里面写上DOS命令语句.然后选择另存为改文

  • Spring整合Quartz实现定时任务调度的方法

    最近项目中需要实现定时执行任务,比如定时计算会员的积分.调用第三方接口等,由于项目采用spring框架,所以这里结合spring框架来介绍. 编写作业类 即普通的pojo,如下: package com.pcmall.task; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class TaskA { private static Logger logger = LoggerFactory.getLogger(Ta

  • js实现的定时关闭页面或定时提醒效果代码

    v\:*{behavior:url(#default#vml)} v\:oval,#oDiv{position=absolute;width=200;height=200} #stay{position=absolute;top=70;left=59;color=RED;padding=6;font=900 20/1.3} #input input{border-left=0;border-right=0} Cool Clock 9?'':'_')+per+'%'" style=position

随机推荐