首页 > 资讯 > 后端开发 > GO >浅析golang怎么实现延时任务

666

分享到

浅析golang怎么实现延时任务

Go 后端 2023-05-14 20:05:35 666人浏览泡泡鱼

摘要

golang怎么实现延时任务？下面本篇文章给大家分享一套基于Golang实现的延时任务方案，希望对大家有所帮助！在实际业务场景中，我们有时候会碰到一些延时的需求：例如，在电商平台，运营在管理后台添加商品后，不需要立刻展示在前台，而是在之后某

golang怎么实现延时任务？下面本篇文章给大家分享一套基于Golang实现的延时任务方案，希望对大家有所帮助！

浅析golang怎么实现延时任务

在实际业务场景中，我们有时候会碰到一些延时的需求：例如，在电商平台，运营在管理后台添加商品后，不需要立刻展示在前台，而是在之后某个时间点才展现。

当然，我们有很多种思路，可以应对这个问题。例如，将待发布商品信息添加到db，然后通过定时任务轮询数据表的方式，查询当前时间点的发布商品；又比如，将商品信息全部添加到Redis中，通过SortSet属性完成这个功能。最终的选择，取决于我们的业务场景和运行环境。

在这里，我想给大家分享一套，基于golang实现的延时任务方案。

你可以收获

golang管道的灵活运用
golang timer的应用
golang切片元素插入排序的实现思路
golang延时任务的实现思路

正文

思维导图

为了让大家有一个大致的印象，我将正文的大纲列在下面。

实现思路

我们都知道，任何一种队列，实际上都是存在生产者和消费者两部分的。只不过，延时任务相对于普通队列，多了一个延时的特性罢了。

1、生产者

从生产者的角度上讲，当用户推送一个任务过来的时候，会携带着延迟执行的时间数值。为了让这个任务到预定时刻能执行，我们需要将这个任务放在内存里储存一段时间，并且时间是一维的，在不断增长。那么，我们用什么数据结构存储呢？

（1）选择一：map。由于map具有无序性，无法按照执行时间排序，我们无法保证取出的任务是否是当前时间点需要执行的，所以排除这个选项。

（2）选择二：channel。的确，channel有时候可以看作队列，然而，它的输出和输入严格遵循着“先进先出”的原则，遗憾的是，先进的任务未必就是先执行的，因此，channel也并不合适。

（3）选择三：slice。切片貌似可行，因为切片元素是具有有序性的，所以，如果我们能够按照执行时间的顺序排列好所有的切片元素，那么，每次只要读取切片的头元素（也可能是尾元素），就可以得到我们要的任务。

2、消费者

从消费者的角度来说，它最大的难点在于，如何让每个任务，在特定的时间点被消费。那么，针对每一个任务，我们如何实现，让它等待一段时间后再执行呢？

没错，就是timer。

总结下来，“切片+timer”的组合，应该是可以达到目的的。

步步为营

1、数据流

（1）用户调用InitDelayQueue() ，初始化延时任务对象。

（2）开启协程，监听任务操作管道（add/delete信号），以及执行时间管道（timer.C信号）。

（3）用户发出add/delete信号。

（4）（2）中的协程捕捉到（3）中的信号，对任务列表进行变更。

（5）当任务执行的时间点到达的时候（timer.C管道有元素输出的时候），执行任务。

2、数据结构

（1）延时任务对象

// 延时任务对象
type DelayQueue struct {
   tasks                 []*task             // 存储任务列表的切片
   add                   chan *task          // 用户添加任务的管道信号
   remove                chan string         // 用户删除任务的管道信号
   waitRemoveTaskMapping map[string]struct{} // 等待删除的任务id列表
}

这里需要注意，有一个waitRemoveTaskMapping字段。由于要删除的任务，可能还在add管道中，没有及时更新到tasks字段中，所以，需要临时记录下客户要删除的任务id。

（2）任务对象

// 任务对象
type task struct {
   id       string    // 任务id
   execTime time.Time // 执行时间
   f        func()    // 执行函数
}

3、初始化延时任务对象

// 初始化延时任务对象
func InitDelayQueue() *DelayQueue {
   q := &DelayQueue{
      add:                   make(chan *task, 10000),
      remove:                make(chan string, 100),
      waitRemoveTaskMapping: make(map[string]struct{}),
   }

   return q
}

在这个过程中，我们需要对用户对任务的操作信号，以及任务的执行时间信号进行监听。

func (q *DelayQueue) start() {
   for {
      // to do something...

      select {
      case now := <-timer.C:
         // 任务执行时间信号
         // to do something...
      case t := <-q.add:
         // 任务推送信号
         // to do something...
      case id := <-q.remove:
         // 任务删除信号
         // to do something...
      }
   }
}

完善我们的初始化方法：

// 初始化延时任务对象
func InitDelayQueue() *DelayQueue {
   q := &DelayQueue{
      add:                   make(chan *task, 10000),
      remove:                make(chan string, 100),
      waitRemoveTaskMapping: make(map[string]struct{}),
   }

   // 开启协程，监听任务相关信号
   go q.start()
   return q
}

4、生产者推送任务

生产者推送任务的时候，只需要将任务加到add管道中即可，在这里，我们生成一个任务id，并返回给用户。

// 用户推送任务
func (q *DelayQueue) Push(timeInterval time.Duration, f func()) string {
   // 生成一个任务id，方便删除使用
   id := genTaskId()
   t := &task{
      id:       id,
      execTime: time.Now().Add(timeInterval),
      f:        f,
   }

   // 将任务推到add管道中
   q.add <- t
   return id
}

5、任务推送信号的处理

在这里，我们要将用户推送的任务放到延时任务的tasks字段中。由于，我们需要将任务按照执行时间顺序排序，所以，我们需要找到新增任务在切片中的插入位置。又因为，插入之前的任务列表已经是有序的，所以，我们可以采用二分法处理。

// 使用二分法判断新增任务的插入位置
func (q *DelayQueue) getTaskInsertIndex(t *task, leftIndex, rightIndex int) (index int) {
   if len(q.tasks) == 0 {
      return
   }

   length := rightIndex - leftIndex
   if q.tasks[leftIndex].execTime.Sub(t.execTime) >= 0 {
      // 如果当前切片中最小的元素都超过了插入的优先级，则插入位置应该是最左边
      return leftIndex
   }

   if q.tasks[rightIndex].execTime.Sub(t.execTime) <= 0 {
      // 如果当前切片中最大的元素都没超过插入的优先级，则插入位置应该是最右边
      return rightIndex + 1
   }

   if length == 1 && q.tasks[leftIndex].execTime.Before(t.execTime) && q.tasks[rightIndex].execTime.Sub(t.execTime) >= 0 {
      // 如果插入的优先级刚好在仅有的两个优先级之间，则中间的位置就是插入位置
      return leftIndex + 1
   }

   middleVal := q.tasks[leftIndex+length/2].execTime

   // 这里用二分法递归的方式，一直寻找正确的插入位置
   if t.execTime.Sub(middleVal) <= 0 {
      return q.getTaskInsertIndex(t, leftIndex, leftIndex+length/2)
   } else {
      return q.getTaskInsertIndex(t, leftIndex+length/2, rightIndex)
   }
}

找到正确的插入位置后，我们才能将任务准确插入：

// 将任务添加到任务切片列表中
func (q *DelayQueue) addTask(t *task) {
   // 寻找新增任务的插入位置
   insertIndex := q.getTaskInsertIndex(t, 0, len(q.tasks)-1)
   // 找到了插入位置，更新任务列表
   q.tasks = append(q.tasks, &task{})
   copy(q.tasks[insertIndex+1:], q.tasks[insertIndex:])
   q.tasks[insertIndex] = t
}

那么，在监听add管道的时候，我们直接调用上述addTask() 即可。

func (q *DelayQueue) start() {
   for {
      // to do something...

      select {
      case now := <-timer.C:
         // 任务执行时间信号
         // to do something...
      case t := <-q.add:
         // 任务推送信号
         q.addTask(t)
      case id := <-q.remove:
         // 任务删除信号
         // to do something...
      }
   }
}

6、生产者删除任务

// 用户删除任务
func (q *DelayQueue) Delete(id string) {
   q.remove <- id
}

7、任务删除信号的处理

在这里，我们可以遍历任务列表，根据删除任务的id找到其在切片中的对应index。

// 删除指定任务
func (q *DelayQueue) deleteTask(id string) {
   deleteIndex := -1
   for index, t := range q.tasks {
      if t.id == id {
         // 找到了在切片中需要删除的所以呢
         deleteIndex = index
         break
      }
   }

   if deleteIndex == -1 {
      // 如果没有找到删除的任务，说明任务还在add管道中，来不及更新到tasks中，这里我们就将这个删除id临时记录下来
      // 注意，这里暂时不考虑，任务id非法的特殊情况
      q.waitRemoveTaskMapping[id] = struct{}{}
      return
   }

   if len(q.tasks) == 1 {
      // 删除后，任务列表就没有任务了
      q.tasks = []*task{}
      return
   }

   if deleteIndex == len(q.tasks)-1 {
      // 如果删除的是，任务列表的最后一个元素，则执行下列代码
      q.tasks = q.tasks[:len(q.tasks)-1]
      return
   }

   // 如果删除的是，任务列表的其他元素，则需要将deleteIndex之后的元素，全部向前挪动一位
   copy(q.tasks[deleteIndex:len(q.tasks)-1], q.tasks[deleteIndex+1:len(q.tasks)-1])
   q.tasks = q.tasks[:len(q.tasks)-1]
   return
}

然后，我们可以完善start()方法了。

func (q *DelayQueue) start() {
   for {
      // to do something...

      select {
      case now := <-timer.C:
         // 任务执行时间信号
         // to do something...
      case t := <-q.add:
         // 任务推送信号
         q.addTask(t)
      case id := <-q.remove:
         // 任务删除信号
         q.deleteTask(id)
      }
   }
}

8、任务执行信号的处理

start()执行的时候，分成两种情况：任务列表为空，只需要监听add管道即可；任务列表不为空的时候，需要监听所有管道。任务执行信号，主要是依靠timer来实现，属于第二种情况。

func (q *DelayQueue) start() {
   for {
      if len(q.tasks) == 0 {
           // 任务列表为空的时候，只需要监听add管道
           select {
           case t := <-q.add:
              //添加任务
              q.addTask(t)
           }
        
           continue
      }

      // 任务列表不为空的时候，需要监听所有管道

      // 任务的等待时间=任务的执行时间-当前的时间
      currentTask := q.tasks[0]
      timer := time.NewTimer(currentTask.execTime.Sub(time.Now()))

      select {
      case now := <-timer.C:
         // 任务执行信号
         timer.Stop()
        if _, isRemove := q.waitRemoveTaskMapping[currentTask.id]; isRemove {
           // 之前客户已经发出过该任务的删除信号，因此需要结束任务，刷新任务列表
           q.endTask()
           delete(q.waitRemoveTaskMapping, currentTask.id)
           continue
        }
        
        // 开启协程，异步执行任务
        go q.execTask(currentTask, now)
        // 任务结束，刷新任务列表
        q.endTask()
      case t := <-q.add:
         // 任务推送信号
         timer.Stop()
         q.addTask(t)
      case id := <-q.remove:
         // 任务删除信号
         timer.Stop()
         q.deleteTask(id)
      }
   }
}

执行任务：

// 执行任务
func (q *DelayQueue) execTask(task *task, currentTime time.Time) {
   if task.execTime.After(currentTime) {
      // 如果当前任务的执行时间落后于当前时间，则不执行
      return
   }

   // 执行任务
   task.f()
   return
}

结束任务，刷新任务列表：

// 一个任务去执行了，刷新任务列表
func (q *DelayQueue) endTask() {
   if len(q.tasks) == 1 {
      q.tasks = []*task{}
      return
   }

   q.tasks = q.tasks[1:]
}

9、完整代码

delay_queue.go

package delay_queue

import (
   "go.mongoDB.org/mongo-driver/bson/primitive"
   "time"
)

// 延时任务对象
type DelayQueue struct {
   tasks                 []*task             // 存储任务列表的切片
   add                   chan *task          // 用户添加任务的管道信号
   remove                chan string         // 用户删除任务的管道信号
   waitRemoveTaskMapping map[string]struct{} // 等待删除的任务id列表
}

// 任务对象
type task struct {
   id       string    // 任务id
   execTime time.Time // 执行时间
   f        func()    // 执行函数
}

// 初始化延时任务对象
func InitDelayQueue() *DelayQueue {
   q := &DelayQueue{
      add:                   make(chan *task, 10000),
      remove:                make(chan string, 100),
      waitRemoveTaskMapping: make(map[string]struct{}),
   }

   // 开启协程，监听任务相关信号
   go q.start()
   return q
}

// 用户删除任务
func (q *DelayQueue) Delete(id string) {
   q.remove <- id
}

// 用户推送任务
func (q *DelayQueue) Push(timeInterval time.Duration, f func()) string {
   // 生成一个任务id，方便删除使用
   id := genTaskId()
   t := &task{
      id:       id,
      execTime: time.Now().Add(timeInterval),
      f:        f,
   }

   // 将任务推到add管道中
   q.add <- t
   return id
}

// 监听各种任务相关信号
func (q *DelayQueue) start() {
   for {
      if len(q.tasks) == 0 {
         // 任务列表为空的时候，只需要监听add管道
         select {
         case t := <-q.add:
            //添加任务
            q.addTask(t)
         }

         continue
      }

      // 任务列表不为空的时候，需要监听所有管道

      // 任务的等待时间=任务的执行时间-当前的时间
      currentTask := q.tasks[0]
      timer := time.NewTimer(currentTask.execTime.Sub(time.Now()))

      select {
      case now := <-timer.C:
         timer.Stop()
         if _, isRemove := q.waitRemoveTaskMapping[currentTask.id]; isRemove {
            // 之前客户已经发出过该任务的删除信号，因此需要结束任务，刷新任务列表
            q.endTask()
            delete(q.waitRemoveTaskMapping, currentTask.id)
            continue
         }

         // 开启协程，异步执行任务
         go q.execTask(currentTask, now)
         // 任务结束，刷新任务列表
         q.endTask()
      case t := <-q.add:
         // 添加任务
         timer.Stop()
         q.addTask(t)
      case id := <-q.remove:
         // 删除任务
         timer.Stop()
         q.deleteTask(id)
      }
   }
}

// 执行任务
func (q *DelayQueue) execTask(task *task, currentTime time.Time) {
   if task.execTime.After(currentTime) {
      // 如果当前任务的执行时间落后于当前时间，则不执行
      return
   }

   // 执行任务
   task.f()
   return
}

// 一个任务去执行了，刷新任务列表
func (q *DelayQueue) endTask() {
   if len(q.tasks) == 1 {
      q.tasks = []*task{}
      return
   }

   q.tasks = q.tasks[1:]
}

// 将任务添加到任务切片列表中
func (q *DelayQueue) addTask(t *task) {
   // 寻找新增任务的插入位置
   insertIndex := q.getTaskInsertIndex(t, 0, len(q.tasks)-1)
   // 找到了插入位置，更新任务列表
   q.tasks = append(q.tasks, &task{})
   copy(q.tasks[insertIndex+1:], q.tasks[insertIndex:])
   q.tasks[insertIndex] = t
}

// 删除指定任务
func (q *DelayQueue) deleteTask(id string) {
   deleteIndex := -1
   for index, t := range q.tasks {
      if t.id == id {
         // 找到了在切片中需要删除的所以呢
         deleteIndex = index
         break
      }
   }

   if deleteIndex == -1 {
      // 如果没有找到删除的任务，说明任务还在add管道中，来不及更新到tasks中，这里我们就将这个删除id临时记录下来
      // 注意，这里暂时不考虑，任务id非法的特殊情况
      q.waitRemoveTaskMapping[id] = struct{}{}
      return
   }

   if len(q.tasks) == 1 {
      // 删除后，任务列表就没有任务了
      q.tasks = []*task{}
      return
   }

   if deleteIndex == len(q.tasks)-1 {
      // 如果删除的是，任务列表的最后一个元素，则执行下列代码
      q.tasks = q.tasks[:len(q.tasks)-1]
      return
   }

   // 如果删除的是，任务列表的其他元素，则需要将deleteIndex之后的元素，全部向前挪动一位
   copy(q.tasks[deleteIndex:len(q.tasks)-1], q.tasks[deleteIndex+1:len(q.tasks)-1])
   q.tasks = q.tasks[:len(q.tasks)-1]
   return
}

// 寻找任务的插入位置
func (q *DelayQueue) getTaskInsertIndex(t *task, leftIndex, rightIndex int) (index int) {
   // 使用二分法判断新增任务的插入位置
   if len(q.tasks) == 0 {
      return
   }

   length := rightIndex - leftIndex
   if q.tasks[leftIndex].execTime.Sub(t.execTime) >= 0 {
      // 如果当前切片中最小的元素都超过了插入的优先级，则插入位置应该是最左边
      return leftIndex
   }

   if q.tasks[rightIndex].execTime.Sub(t.execTime) <= 0 {
      // 如果当前切片中最大的元素都没超过插入的优先级，则插入位置应该是最右边
      return rightIndex + 1
   }

   if length == 1 && q.tasks[leftIndex].execTime.Before(t.execTime) && q.tasks[rightIndex].execTime.Sub(t.execTime) >= 0 {
      // 如果插入的优先级刚好在仅有的两个优先级之间，则中间的位置就是插入位置
      return leftIndex + 1
   }

   middleVal := q.tasks[leftIndex+length/2].execTime

   // 这里用二分法递归的方式，一直寻找正确的插入位置
   if t.execTime.Sub(middleVal) <= 0 {
      return q.getTaskInsertIndex(t, leftIndex, leftIndex+length/2)
   } else {
      return q.getTaskInsertIndex(t, leftIndex+length/2, rightIndex)
   }
}

func genTaskId() string {
   return primitive.NewObjectID().Hex()
}

测试代码：delay_queue_test.go

package delay_queue

import (
   "fmt"
   "testing"
   "time"
)

func TestDelayQueue(t *testing.T) {
   q := InitDelayQueue()
   for i := 0; i < 100; i++ {
      go func(i int) {
         id := q.Push(time.Duration(i)*time.Second, func() {
            fmt.Printf("%d秒后执行...\n", i)
            return
         })

         if i%7 == 0 {
            q.Delete(id)
         }
      }(i)
   }

   time.Sleep(time.Hour)
}

头脑风暴

上面的方案，的确实现了延时任务的效果，但是其中仍然有一些问题，仍然值得我们思考和优化。

1、按照上面的方案，如果大量延时任务的执行时间，集中在同一个时间点，会造成短时间内timer频繁地创建和销毁。

2、上述方案相比于time.AfterFunc()方法，我们需要在哪些场景下作出取舍。

3、如果服务崩溃或重启，如何去持久化队列中的任务。

小结

本文和大家讨论了延时任务在golang中的一种实现方案，在这个过程中，一次性定时器timer、切片、管道等golang特色，以及二分插入等常见算法都体现得淋漓尽致。

【相关推荐：Go视频教程、编程教学】

以上就是浅析golang怎么实现延时任务的详细内容，更多请关注编程网其它相关文章！

您可能感兴趣的文档:

Go语言（Golang）教程

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: 浅析golang怎么实现延时任务

本文链接: https://www.lsjlt.com/news/204129.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

浅析golang怎么实现延时任务

golang怎么实现延时任务？下面本篇文章给大家分享一套基于golang实现的延时任务方案，希望对大家有所帮助！在实际业务场景中，我们有时候会碰到一些延时的需求：例如，在电商平台，运营在管理后台添加商品后，不需要立刻展示在前台，而是在之后某...

99+

2023-05-14

Go 后端
golang如何实现延时任务

这篇文章主要讲解了“golang如何实现延时任务”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“golang如何实现延时任务”吧！实现思路我们都知道，任何一种队列，实际上都是存在生产者和消费者...

99+

2023-07-05
golang延时任务如何实现

这篇文章主要介绍“golang延时任务如何实现”，在日常操作中，相信很多人在golang延时任务如何实现问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”golang延时任务如何实现”的疑惑有所帮助！接下来，请跟...

99+

2023-07-05
一文详解golang延时任务的实现

目录前言你可以收获正文思维导图实现思路步步为营1、数据流2、数据结构3、初始化延时任务对象4、生产者推送任务5、任务推送信号的处理6、生产者删除任务7、任务删除信号的处理8、任务执行...

99+

2023-03-20

golang延时任务 go 延时
延时任务的四种实现方式

什么是延迟任务？顾明思议，我们把需要延迟执行的任务叫做延迟任务。延迟任务的使用场景有以下这些：红包 24 小时未被查收，需要延迟执退还业务；每个月账单日，需要给用户发送当月的对账单；订单下单之后 30 分钟后，用户如果没...

99+

2023-10-04

java Powered by 金山文档
C#通过rabbitmq实现定时任务(延时队列)

本文主要讲解如何通过RabbitMQ实现定时任务(延时队列) 环境准备需要在MQ中进行安装插件地址链接插件介绍地址：https://www.rabbitmq.com/blog/...

99+

2024-04-02
Java DelayQueue实现任务延时示例讲解

在项目中有使用到延时队列的场景，做个简单的记录说明；首先DelayQueue实现了BlockingQueue，加入其中的元素必须实现Delayed接口；当生产者元素调用put往其中...

99+

2024-04-02
FreeRTOS实时操作系统空闲任务的阻塞延时怎么实现

这篇文章主要介绍“FreeRTOS实时操作系统空闲任务的阻塞延时怎么实现”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“FreeRTOS实时操作系统空闲任务的阻塞延时怎么实现”文章能帮助大家解决问题。...

99+

2023-06-29
Java中怎么实现单任务延迟

今天就跟大家聊聊有关Java中怎么实现单任务延迟，可能很多人都不太了解，为了让大家更加了解，小编给大家总结了以下内容，希望大家根据这篇文章可以有所收获。Java单任务延迟代码创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行...

99+

2023-06-17
golang定时任务中异步回调怎么实现

在golang中，可以使用goroutine和channel来实现异步回调。下面是一个示例代码： package main im...

99+

2023-10-22

golang
如何分析Linux下at延时任务和crontab定时任务命令

本篇文章为大家展示了如何分析Linux下at延时任务和crontab定时任务命令，内容简明扼要并且容易理解，绝对能使你眼前一亮，通过这篇文章的详细介绍希望你能有所收获。在Linux系统中，要想设定及时任务可以用at：一次性定时任务计划执行和...

99+

2023-06-28
使用Redis实现延时任务的解决方案

最近在生产环境刚好遇到了延时任务的场景，调研了一下目前主流的方案，分析了一下优劣并且敲定了最终的方案。这篇文章记录了调研的过程，以及初步方案的实现。候选方案对比下面是想到的几种实现延时任务的方案，总结了...

99+

2024-04-02
FreeRTOS实时操作系统空闲任务的阻塞延时实现

目录什么是阻塞延时、为什么需要空闲任务空闲任务的实现阻塞延时的实现xTicksToDelay 递减SysTick初始化仿真什么是阻塞延时、为什么需要空闲任务 RTOS中的延时叫阻塞延...

99+

2024-04-02
RabbitMQ消息队列怎么实现延迟任务

这篇文章主要介绍“RabbitMQ消息队列怎么实现延迟任务”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“RabbitMQ消息队列怎么实现延迟任务”文章能帮助大家解决问题。一、序言延迟任务应用广泛，延...

99+

2023-06-29
springboot执行延时任务之DelayQueue实例

目录springboot执行延时任务之DelayQueueDelayQueue是什么？使用步骤日常开发延迟任务技术对比总结springboot执行延时任务之DelayQueue 提示...

99+

2023-02-14

springboot执行延时任务 springboot DelayQueue springboot延时任务
基于rabbitmq延迟插件怎么实现分布式延迟任务

本文小编为大家详细介绍“基于rabbitmq延迟插件怎么实现分布式延迟任务”，内容详细，步骤清晰，细节处理妥当，希望这篇“基于rabbitmq延迟插件怎么实现分布式延迟任务”文章能帮助大家解决疑惑，下面跟着小编的思路慢慢深入，一起来学习新知...

99+

2023-06-26
SpringBoot定时任务怎么实现

这篇文章主要讲解了“SpringBoot定时任务怎么实现”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“SpringBoot定时任务怎么实现”吧！SpringBoot定时任务主要由两个注解完成...

99+

2023-06-05
python怎么实现定时任务

这篇文章主要介绍python怎么实现定时任务，文中介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们一定要看完！用Python实现定时任务有些时候我们需要每隔一段时间就要执行一段程序，或者是往复循环执行某一个任务。比如博主在上篇文章讲的爬...

99+

2023-06-14
node怎么实现定时任务

本教程操作环境：linux7.3系统、node18.4.0版、Dell G3电脑。node怎么实现定时任务node定时任务（node-schedule模块）实现一个每天凌晨十二点更新服务器上的git代码的功能koa2框架下的app.js文件...

99+

2022-11-22

定时任务 node
freertos实时操作系统空闲任务阻塞延时示例解析

目录前言空闲任务阻塞延时SysTick实验现象前言阻塞态：如果一个任务当前正在等待某个外部事件，则称它处于阻塞态。 rtos中的延时叫阻塞延时，即任务需要延时的时候，会放弃CPU的...

99+

2024-04-02