基于最小堆实现的定时器（HeapTimer）

已于 2023-03-28 15:58:57 修改
阅读量1.1k 收藏 4
点赞数 4
分类专栏： webServer 文章标签： 数据结构 c++
于 2022-12-25 16:38:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50437588/article/details/128435637
版权

思路：

实现Reactor模式的服务器时，通常需要和非阻塞的IO函数相结合，此外还存在保持与客户之间的连接等定时任务，所以如何将这些定时任务有效地组织起来十分重要。

本文实现了一个基于最小堆的定时器，插入O(logn)、删除O(1)、查找O(1)，效率较高。

定时任务的结构

typedef std::function<void()> TimeoutCallBack;
typedef std::chrono::high_resolution_clock Clock;
typedef std::chrono::milliseconds MS;
typedef Clock::time_point TimeStamp;

struct TimerNode
{
	int id;//定时任务标识
	TimeStamp expires;//超时时间
	TimeoutCallBack func;//超时回调函数
	bool operator<(const TimerNode& other)
	{
		return this->expires < other.expires;
	}
};

定时器的结构

class HeapTimer
{
public:
	HeapTimer() { heap.reserve(64); }
	~HeapTimer() 
    { 
        heap.clear();
        ref.clear(); 
    }
private:
	std::vector<TimerNode> heap;//最小堆
	std::unordered_map<int, size_t> ref;//ref[定时任务标识]=最小堆内的下标
};

主要的成员函数：

（1）上浮        void HeapTimer::swim(size_t i)

void HeapTimer::swim(size_t i)//上浮
{
	assert(i>=0&&i<heap.size());
    while (i > 0)
    {
        size_t parent = (i - 1) / 2;
        if (heap[parent] < heap[i])
            break;
        swapNode(i, parent);
        i = parent;
    }
}

（2）下沉        bool HeapTimer::sink(size_t index,size_t n)

bool HeapTimer::sink(size_t index,size_t n)//下沉
{
    assert(index >= 0 && index < heap.size());
    assert(n >= 0 && n <= heap.size());
    size_t i = index;
    while (i * 2 + 1<n)
    {
        size_t left = i * 2 + 1;
        size_t right = i * 2 + 2;
        size_t older = left;
        if (right<n && heap[right]<heap[older])
        {
            older = right;
        }
        if (heap[i]<heap[older])
            break;
        swapNode(i, older);
        i = older;
    }
    return i > index;
}

 （3）交换       void HeapTimer::swapNode(size_t i, size_t j)

这里直接选择STL通用的swap函数，std::swap(i, j)默认采用深拷贝，所以如果交换的两个数据结构内含有指针成员，应该自己定制swap函数，交换指针即可，无需进行默认的深拷贝动作。

但是，定时任务TimerNode内并无指针成员，默认的swap函数效率已足够高。

void HeapTimer::swapNode(size_t i, size_t j)
{
    assert(i >= 0 && i < heap.size());
    assert(j >= 0 && j < heap.size());
    std::swap(heap[i], heap[j]);
    ref[heap[i].id] = i;
    ref[heap[j].id] = j;
}

（4）添加定时任务        void HeapTimer::add(int id, int timeout, const TimeoutCallBack& func)

void HeapTimer::add(int id, int timeout, const TimeoutCallBack& func)
{
    assert(id >= 0);
    size_t i;
    if (ref.count(id) == 0)
    {
        i = heap.size();
        ref[id] = i;//向堆底的最后一个位置加入新的定时任务
        heap.push_back({ id,Clock::now() + MS(timeout),func });
        swim(i);//调整堆结构（上浮）
    }
    else//若已存在，则更新超时时间
    {
        i = ref[id];
        heap[i].expires = Clock::now() + MS(timeout);
        heap[i].func = func;
        if (!sink(i, heap.size()))
        {
            swim(i);
        }
    }
}

（5）删除指定任务

void HeapTimer::del(size_t i)                //删除指定下标的定时任务

void HeapTimer::doWork(int id)            //删除指定标识的定时任务

void HeapTimer::del(size_t i)//删除指定下标的定时任务
{
    assert(!heap.empty() && i >= 0 && i < heap.size());
    size_t n = heap.size() - 1;
    if (i < n)
    {
        swapNode(i, n);//与堆底的最后一个元素交换位置
        if (!sink(i, n))//调整堆结构
        {
            swim(i);
        }
    }
    ref.erase(heap.back().id);
    heap.pop_back();
}

void HeapTimer::doWork(int id)//删除指定标识的定时任务
{
    if (heap.empty() || ref.count(id) == 0)
    {
        return;
    }
    size_t i = ref[id];
    TimerNode cur = heap[i];
    cur.func();
    del(i);
}

 （6）清除超时节点        void HeapTimer::tick()

void HeapTimer::tick()//清除超时节点
{
    if (heap.empty())
    {
        return;
    }
    while (!heap.empty())
    {
        TimerNode cur = heap.front();
        if (std::chrono::duration_cast<MS>(cur.expires - Clock::now()).count() > 0)
        {
            break;
        }
        cur.func();
        pop();
    }
}

void HeapTimer::pop()//清除堆顶节点
{
    assert(!heap.empty());
    del(0);
}

（7）心搏函数        int HeapTimer::getNextTick()

设计思路：将所有定时任务中超时时间最小（最快到期）的一个定时任务的超时值作为心搏间隔，这样一旦下一次调用心搏函数时，tick()函数被调用，此时这个超时时间最小的定时任务必然到期，就在tick()函数中处理这个超时任务。然后，再次从剩余的任务中找出一个超时时间最小的，将这段时间设置为下一次心搏间隔，如此不断反复。

int HeapTimer::getNextTick()//得到堆顶节点剩余的阻塞时间（心搏函数）
{
    tick();
    size_t res = -1;
    if (!heap.empty())
    {
        res = std::chrono::duration_cast<MS>(heap.front().expires - Clock::now()).count();
        if (res < 0)
            res = 0;
    }
    return res;
}

 源码：

heaptimer.h

#ifndef HEAP_TIMER_H
#define HEAP_TIMER_H

#include<functional>
#include<chrono>
#include<assert.h>
#include<unordered_map>
#include<vector>

typedef std::function<void()> TimeoutCallBack;
typedef std::chrono::high_resolution_clock Clock;
typedef std::chrono::milliseconds MS;
typedef Clock::time_point TimeStamp;

struct TimerNode
{
	int id;
	TimeStamp expires;
	TimeoutCallBack func;
	bool operator<(const TimerNode& other)
	{
		return this->expires < other.expires;
	}
};

//基于最小堆的定时器
class HeapTimer
{
public:
	HeapTimer() { heap.reserve(64); }

	~HeapTimer() { clear(); }

	void add(int id, int timeOut, const TimeoutCallBack& func);

	void adjust(int id, int newExpires);

	void doWork(int id);

	void tick();

	void pop();
	
	void clear();
	
	int getNextTick();

private:
	std::vector<TimerNode> heap;

	std::unordered_map<int, size_t> ref;

	void swim(size_t i);

	bool sink(size_t index, size_t n);

	void del(size_t i);

	void swapNode(size_t i, size_t j);
};

#endif // !HEAP_TIMER_H

heaptimer.cpp 

#include "heaptimer.h"

void HeapTimer::swim(size_t i)//上浮
{
	assert(i>=0&&i<heap.size());
    while (i > 0)
    {
        size_t parent = (i - 1) / 2;
        if (heap[parent] < heap[i])
            break;
        swapNode(i, parent);
        i = parent;
    }
}

void HeapTimer::swapNode(size_t i, size_t j)
{
    assert(i >= 0 && i < heap.size());
    assert(j >= 0 && j < heap.size());
    std::swap(heap[i], heap[j]);
    ref[heap[i].id] = i;
    ref[heap[j].id] = j;
}

bool HeapTimer::sink(size_t index,size_t n)//下沉
{
    assert(index >= 0 && index < heap.size());
    assert(n >= 0 && n <= heap.size());
    size_t i = index;
    while (i * 2 + 1<n)
    {
        size_t left = i * 2 + 1;
        size_t right = i * 2 + 2;
        size_t older = left;
        if (right<n && heap[right]<heap[older])
        {
            older = right;
        }
        if (heap[i]<heap[older])
            break;
        swapNode(i, older);
        i = older;
    }
    return i > index;
}

void HeapTimer::add(int id, int timeout, const TimeoutCallBack& func)//添加新的时间节点
{
    assert(id >= 0);
    size_t i;
    if (ref.count(id) == 0)
    {
        i = heap.size();
        ref[id] = i;
        heap.push_back({ id,Clock::now() + MS(timeout),func });
        swim(i);
    }
    else//若已存在，则更新阻塞时间
    {
        i = ref[id];
        heap[i].expires = Clock::now() + MS(timeout);
        heap[i].func = func;
        if (!sink(i, heap.size()))
        {
            swim(i);
        }
    }
}

void HeapTimer::del(size_t i)//删除指定位置的时间节点
{
    assert(!heap.empty() && i >= 0 && i < heap.size());
    size_t n = heap.size() - 1;
    if (i < n)
    {
        swapNode(i, n);
        if (!sink(i, n))
        {
            swim(i);
        }
    }
    ref.erase(heap.back().id);
    heap.pop_back();
}

void HeapTimer::doWork(int id)//删除指定序号的时间节点
{
    if (heap.empty() || ref.count(id) == 0)
    {
        return;
    }
    size_t i = ref[id];
    TimerNode cur = heap[i];
    cur.func();
    del(i);
}

void HeapTimer::adjust(int id, int timeout)//更新阻塞时间
{
    assert(!heap.empty() && ref.count(id) > 0);
    heap[ref[id]].expires = Clock::now() + MS(timeout);
    sink(ref[id], heap.size());
}

void HeapTimer::tick()//清除超时节点
{
    if (heap.empty())
    {
        return;
    }
    while (!heap.empty())
    {
        TimerNode cur = heap.front();
        if (std::chrono::duration_cast<MS>(cur.expires - Clock::now()).count() > 0)
        {
            break;
        }
        cur.func();
        pop();
    }
}

void HeapTimer::pop()//删除堆顶节点
{
    assert(!heap.empty());
    del(0);
}

void HeapTimer::clear()
{
    ref.clear();
    heap.clear();
}

int HeapTimer::getNextTick()//得到堆顶节点剩余的阻塞时间（心搏函数）
{
    tick();
    size_t res = -1;
    if (!heap.empty())
    {
        res = std::chrono::duration_cast<MS>(heap.front().expires - Clock::now()).count();
        if (res < 0)
            res = 0;
    }
    return res;
}
{(sunburst)}
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
基于VHDL的99小时定时器设计及实现
01-19
　传统的定时器硬件连接比较复杂，可靠性差，而且计时时间短，难以满足需要。本设计采用可编程芯片和VHDL语言进行软硬件设计，不但可使硬件大为简化，而且稳定性也有明显提高。由于可编程芯片的频率精度可达到50 MHz...
基于Rxjava实现轮询定时器
01-20
本文实例为大家分享了Rxjava实现轮询定时器的具体代码，供大家参考，具体内容如下 作用 1、实现了延迟若干毫秒后，执行next操作，只执行一次 2、实现了每隔若干毫秒后，执行next操作，可执行多次 工具类源码 /** ...
webserver--基于小根堆实现定时器，关闭超时的非活跃连接
热门推荐
dont worry about it的博客
03-29 4万+
计算机在工作时，我们打开多个网页，但是不使用的时候，系统自动会进入休眠模式，这样会更加省电，节省资源。同样的， 服务器在工作时，建立好连接后，即使你不用，他也会一直为你服务吗？当然不是，不然可太消耗资源了。对于非活跃的用户，达到了设定的时间，那我们就关闭这个连接，等用户再次需要时再重新建立连接。
高性能定时器1——最小堆实现
Peerless__的博客
10-07 1166
高性能定时器1——时间堆 ​ 在网络程序中我们通常要处理三种事件，网络I/O事件、信号以及定时事件，我们可以使用I/O复用系统调用（select、poll、epoll）将这三类事件进行统一处理。我们通常使用定时器来检测一个客户端的活动状态，服务器程序通常管理着众多定时事件，因此有效地组织这些定时事件，使之能在预期的时间点被触发且不影响服务器的主要逻辑，对于服务器的性能有着至关重要的影响。为此我们需要将每个定时事件分别封装为定时器，并使用某种容器类数据结构，比如：链表、排序链表、最小堆、红黑树以及时间轮等
高性能定时器 时间堆（最小堆）定时器
m0_73915763的博客
08-21 274
由于定时器的触发是由于时间到了，因此只有时间最短的定时器会首先被触发，通过这个原理，我们可以采用最小堆，将按时间顺序排序，堆顶元素是时间最短的定时器，因此只要判断堆顶元素是否被触发即可。因此，我们可以得到：最大堆的根节点的值是最大的，最小堆的根节点的值是最小的。由于堆是一种经过排序的完全二叉树，因此在构建的时候需要对新插入的节点进行一些操作以使其符合堆的性质。下滤是将堆上面不符合条件的节点向下移动的过程，上滤则是将堆下面不符合条件的节点向上移动的过程。堆又分为两种，最大堆、最小堆。
时间堆定时器实现
wangrenhaioylj的博客
09-13 1148
文中前半部分图片大部分来自：https://www.cnblogs.com/chengxiao/p/6129630.html 堆的基本概念： 　　堆是具有以下性质的完全二叉树：每个父结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个父结点的值都小于或等于其左右孩子结点的值，称为小顶堆。 大小堆如下图： 我们将这种逻辑结构映射到数组中，如下图： 我们通过两组简单的公式描述一下上述两种堆的特性： 大顶堆：arr[i] >= arr[2i+1] && arr[i] >=
从零开始实现C++ TinyWebServer（七）---- 进一步优化服务器，剑指定时器小根堆
JehanRio's Private Blog
05-07 3241
昨天晚上失眠了，到2点估计才睡着，我想这估计和下午那杯咖啡没消化完和我看巅峰说唱看到0:40有关系吧（太兴奋了）导致我今天早上9点半才出寝室，做了几个算法题，一上午就过去了。我已经基本习惯把前言部分当成我的free talk部分了，每次开启一篇新的篇章的时候，就总想说点心里话，释放自己压力也好，给后人说说听也好。但我想我的初衷其实并不是写出多么高质量高阅读量的文章，这一条路想必有比我更优秀的人在写，如果你觉得我的文章写的烂，可以点击网页的右上角了。
时间堆原理详解及C++11实现
hjlogzw的博客
03-25 2101
网络编程只会写IO事件？定时器了解一波！本文将深入介绍高效定时器设计----时间堆，以及基于C++11实现和具体使用。
WebServer 高性能服务器 v2
weixin_57209831的博客
03-19 469
本文继续上一篇WebServer 高性能服务器_沐雨橙风24的博客-CSDN博客，主要增加线程池和定时器功能，大幅度提高服务器性能。
用C++实现的高性能WEB服务器
weixin_47243756的博客
03-19 2191
c++
Rec.自学路上的第一个小项目Tiny-Webserver的实现总结
m0_74932004的博客
05-06 1077
*进行读写数据并调用httprequest 来解析数据以及httpresponse来生成响应*/public://初始化客户端的地址数据//从读缓冲区读数据//从写缓冲区写数据//关闭客户端的请求//接口，返回客户端的sockfd//接口，返回客户端的端口号//接口，返回客户端的IP//接口，返回客户端的sockaddr//流程函数，包含reques解析请求，response响应报文int The_WriteBytes() //获取响应报文的总大小。
基于eventloop的java非阻塞网络库，实现了事件驱动，无锁的基于最小堆的定时器，便于扩展的pipeline机.zip
03-23
在这个基于eventloop的Java实现中，我们看到几个核心概念和技术，包括EventLoop（事件循环）、无锁数据结构、最小堆定时器以及Pipeline机制。下面将详细阐述这些知识点。 1. EventLoop（事件循环）： 事件循环是...
基于51单片机的定时器
01-19
基于单片机的定时器原理图如下所示： 我们学单片机是首先学的就是 闪烁，那是用延时程序做的，现在回想起来，这样做不很恰当，为什么呢?我们的主程序做了灯的闪烁，就不能再干其它的事了，难道单片机只能这样工作...
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 246
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
学习记录day19——数据结构 查找算法
最新发布
weixin_64918301的博客
07-25 398
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
java算法原理
jylee的博客
07-25 832
正确回答通过率：40.0%[ 详情 ] 推荐指数： ★★★★ 试题难度： 高难 试题类型： 编程题 ▸ 写笔记试题回答参考思路： >>
数据结构的概念和术语
2303_78660417的博客
07-24 518
数据结构是一门研究非数值计算的程序设计中计算机的操作对象以及它们之间的关系和操作的学科。数据结构的基本数据结构包括两部分，线性结构跟非线性结构。
c语言（7.23）
fhgfyrsg的博客
07-23 707
【代码】c语言（7.23）
web服务器定时器用最小堆实现的
07-28
是的，使用最小堆来实现定时器是一种常见的方法。...通过使用最小堆实现定时器，可以高效地管理大量的定时任务，并且保证任务按照预定的时间顺序执行。这种实现方式在很多Web服务器框架中得到了广泛应用。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值