Linux笔记 高性能定时器

目录

• 时间轮
  • 实现一个简单时间轮
  • 使用时间轮
• 时间堆
  • 什么是最小堆？
    • 插入操作
    • 删除操作
  • 用最小堆实现时间堆
  • 时间堆类的使用
• 参考

介绍两种高性能定时器：时间轮和时机堆。

时间轮

基于排序链表的定时器，使用一条链表存放所有定时器（时间复杂度O(n)），因此存在添加定时器效率偏低的问题。当存在需要大量添加定时器场景时，添加定时器可能会严重影响性能。

时间轮可以有效解决这个问题。下图是一个简单时间轮的示意图：

时机轮内，实线指针指向的一圈（1,2,...,N）代表轮子上的槽（slot）（槽位）。时间轮以恒定速度顺时针转到，每转动一步就指向下一个槽（虚线指针指向的槽），每次转动称为一个滴答（tick）。一个滴答的时间称为时间轮的槽间隔si（slot interval），实际上就是心博时间。

这个时间轮有N个槽位，因此转动一周代表时间Nsi。每个槽位指向一条定时器链表，每条链表上的定时器具有相同的特征：它们的定时时间相差Nsi的整数倍。时间轮利用这个关系将定时器散列到不同链表中：每个定时器有一个超时时间值（int），槽位N个，每个槽位代表si时间，一圈总时间N*si。

假如当前指针指向cs，用户要添加一个定时时间为ti的定时器，则该定时器将被插入槽ts（timer slot）对应的链表中：

ts = (cs + (ti/si)) % N

基于时间轮的定时器，使用哈希表，将定时器散列到不同链表上。这样每条链表上定时器数目明显小于原来排序链表上的定时器数目，插入操作的效率不受定时器数目的影响。

要提高定时精度，需要槽位间隔时间si值变小；要提高执行效率，则要让N值变大，增多链表数量，减少哈希冲突，避免定时器集中到少数几个链表上。

复杂时间轮可能有多个轮子，每个轮子有不同粒度（si）。相邻的两个轮子，精度高的转一圈，精度低的转动一个槽位，就像水表。

实现一个简单时间轮

定时器tw_timer和用户数据client_data

一个tw_timer对象代表一个定时器，封装了属于轮子上哪个槽位、定时器超时回调函数。tw_timer以链表形式组织，包含next、prev域名，头节点位于时间轮槽位上，一个槽位就是一个链表头结点。
由于时间轮转动一圈所代表时间N*si是固定值，所以可以根据用户需要设置的超时时间值，来算出时间轮需要转动的圈数和定时器应该位于时间轮哪个槽位上（即哪个链表上）。

#define BUFFER_SIZE 64
class tw_timer;

/* 绑定socket和定时器 */
struct client_data
{
    sockaddr_in address;
    int sockfd;
    char buf[BUFFER_SIZE];
    tw_timer* timer;
};

/* 定时器类 */
class tw_timer
{
public:
    tw_timer(int rot, int ts)
    : next(NULL), prev(NULL), rotation(rot), time_slot(ts)
    {}

    int rotation;  /* 记录定时器在时间轮转多少圈后生效 */
    int time_slot; /* 记录定时器属于时间轮上哪个槽位(对应的链表) */
    void (*cb_func)(client_data*); /* 定时器回调 */
    client_data* user_data; /* 客户数据 */
    tw_timer* next; /* 指向下一个定时器 */
    tw_timer* prev; /* 指向钱一个定时器 */
};

时间轮类time_wheel
time_wheel有两个重要方法：1）add_timer用于添加定时器；2）del_timer用于删除定时器。

/* 时间轮类 */
class time_wheel
{
public:
    time_wheel() : cur_slot(0)
    {
        for (int i = 0; i < N; ++i) {
            slots[i] = NULL; /* 初始化每个槽的头节点 */
        }
    }
    ~time_wheel()
    {
        /* 遍历每个槽, 并销毁其中的定时器 */
        for (int i = 0; i < N; ++i) {
            tw_timer* tmp = slots[i];
            while (tmp) {
                slots[i] = tmp->next;
                delete tmp;
                tmp = slots[i];
            }
        }
    }

    /* 根据定时值timeout 创建一个定时器, 并把它插入合适的槽中 */
    tw_timer* add_timer(int timeout)
    {
        if (timeout < 0) {
            return NULL;
        }
        int ticks = 0;
        /* 根据带插入定时器的超时值, 计算它将在时间轮转多少个滴答后被触发, 并将该滴答数存储于变量ticks中.
         * 如果待插入定时器的超时值 < 时间轮的槽间隔SI, 则将ticks向上折合为1,　否则就将ticks向下折合为timeout/SI */
        if (timeout < SI) {
            ticks = 1;
        }
        else
        {
            ticks = timeout / SI;
        }
        /* 计算待插入的定时器在时间轮转动多少圈后被触发 */
        int rotation = ticks / N;
        /* 计算待插入的定时器应该被插入哪个槽中 */
        int ts = (cur_slot + (ticks % N)) % N;
        /* 创建新的定时器, 它在时间轮转动rotation圈后被触发, 且位于第ts个槽上 */
        tw_timer* timer = new tw_timer(rotation, ts);
        /* 如果第ts个槽中尚无任何定时器, 则把新建的定时器插入其中, 并将该定时器设置为该槽的头节点 */
        if (!slots[ts]) {
            printf("add timer, rotation is %d, ts is %d, cur_slot is %d\n",
                   rotation, ts, cur_slot);
            slots[ts] = timer;
        }
        /* 否则, 将定时器插入第ts个槽中 */
        else {
            timer->next = slots[ts];
            slots[ts]->prev = timer;
            slots[ts] = timer;
        }
        return timer;
    }

    /* 删除目标定时器timer */
    void del_timer(tw_timer* timer)
    {
        if (!timer) {
            return;
        }
        int ts = timer->time_slot;
        /* slots[ts]是目标定时器所在槽的头节点. 如果目标定时器就是该头节点,
         * 则需要重置第ts个槽的头节点 */
        if (timer == slots[ts]) {
            slots[ts] = slots[ts]->next;
            if (slots[ts]) {
                slots[ts]->prev = NULL;
            }
            delete timer;
        }
        else {
            timer->prev->next = timer->next;
            if (timer->next) {
                timer->next->prev = timer->prev;
            }
            delete timer;
        }
    }

    /* SI时间到后, 调用该函数, 时间轮向前滚动一个槽的间隔.
     * 要求每隔SI时间, 定时调用一次该函数　*/
    void tick()
    {
        tw_timer* tmp = slots[cur_slot]; /* 取得时间轮上当前槽的头节点 */
        printf("current slot is %d\n", cur_slot);
        /* 遍历当前槽位对应链表 */
        while (tmp) {
            printf("tick the timer once\n");
            /* 如果定时器的rotation值 > 0, 则它在这一轮不起作用 */
            if (tmp->rotation > 0) {
                tmp->rotation--;
                tmp = tmp->next;
            }
            /* 否则, 说明定时器已经到期, 于是执行超时任务, 然后删除该定时器 */
            else {
                tmp->cb_func(tmp->user_data);
                if (tmp == slots[cur_slot]) { // 超时定时器就是当前槽位头节点, 删除时要专门处理
                    printf("delete header in cur_slot\n");
                    slots[cur_slot] = tmp->next;
                    delete tmp;
                    if (slots[cur_slot]) {
                        slots[cur_slot]->prev = NULL;
                    }
                    tmp = slots[cur_slot];
                }
                else { // 超时定时器不是当前槽位头节点
                    tmp->prev->next = tmp->next;
                    if (tmp->next) {
                        tmp->next->prev = tmp->prev;
                    }
                    tw_timer* tmp2 = tmp->next;
                    delete tmp;
                    tmp = tmp2;
                }
            }
        }
        cur_slot = ++cur_slot % N; /* 更新时间轮当前槽位, 以反映时间轮的转动 */
    }

private:
    /* 时间轮上槽的数目 */
    static const int N = 60;
    /* 每1秒时间轮转动一次, 即槽间隔1s */
    static const int SI = 1;
    /* 时间轮的槽, 其中每个元素指向一个定时器链表, 链表无序 */
    tw_timer* slots[N];
    int cur_slot; /* 时间轮的当前槽 */
};

使用时间轮

借用muduo函数的EventLoop::runEvery，为心博函数time_wheel::tick()提供1秒周期的入口。

#include "time_wheel.h"
#include "muduo/net/EventLoop.h"
#include <stdio.h>

using namespace muduo;
using namespace muduo::net;

void print(client_data* data)
{
    printf("%s\n", data->buf);
}

int main()
{
    time_wheel wheel;
    tw_timer* timer = wheel.add_timer(5); // 添加5秒后运行的定时器
    timer->cb_func = print;
    timer->user_data = new client_data;
    strncpy(timer->user_data->buf, "hello", strlen("hello"));

    EventLoop loop;
    loop.runEvery(1.0, std::bind(&time_wheel::tick, &wheel)); // 每1秒钟运行1次心博函数tick()
    loop.loop();
    return 0;
}

时间堆

时间轮是以固定频率调用心搏函数tick，在其中依次查找到期（轮数+槽位 确定定时器超时时间）的定时器，然后执行定时器超时回调函数。
另一种设计定时器思路：将所有定时器中超时时间最小的一个定时器的超时值，作为心博间隔。这样，一旦心博函数tick被调用，超时时间最小的定时器必然到期，我们就可以在tick()中处理该定时器。然后，再次从剩余的定时器中找出超时时间最小的那个，并将这段最小时间设为下一次心博间隔。如此反复，实现较为精准的定时。

最小堆用来处理这种定时方案。

什么是最小堆？

最小堆（又称小根堆）是指具有这种特性的一颗完全二叉树：每个节点的值 <= 子节点的值。

如下图所示

比如，节点21，21 <= 24且21<=31；节点24 <= 65且24 <= 26；节点31 <= 32。

树基本操作：插入节点、删除节点。

插入操作

为了将元素X插入最小堆，可以在树下一个空闲位置创建一个空穴（没有元素的节点）。如果X可以放在空穴中而不被破坏堆特性，则插入完成；否则，违法了对特性，执行上虑操作，即交换空穴和其父节点元素，直到X可以被放入空穴。这个过程也称为向上调整堆。

例如，要往上图所示最小堆插入值14，可以按下图所示步骤：

删除操作

删除根节点元素，并且不破坏堆特性。删除时，需要先在根节点创建一个空穴。由于堆少了一个元素，不符合堆特性，因此可以把堆最后一个元素X移动到该堆的某个地方。如果X可以被放入空穴，则删除操作完成；否则，就指向下虑操作，即交换空穴和它的两个儿子节点中较小者。不断进行上述过程，直到X可以被放入空穴。这个过程也称为向下调整堆。

例如，要往上面图示最小堆执行删除（堆顶）操作，可以按下图所示步骤进行：

因为最小堆是一种完全二叉树，因此可以用数组来存储其元素。对于数组中任意位置i上的元素，其左儿子节点在位置2i + 1，右儿子节点在位置2i + 2，父节点在[(i-1) / 2] （i > 0）。与用链表表示堆相比，用数组表示堆节省空间，而且更容易实现堆的插入、删除等操作（数组支持随机访问）。

对时间堆，添加一个定时器时间复杂度：O(logn)；删除一个定时器时间复杂度：O(1)；执行一个定时器时间复杂度：O(1)。

用最小堆实现时间堆

用最小堆实现的定时器称为时间堆。

用户数据类client_data 和 定时器类heap_timer

#define BUFFER_SIZE 64

class heap_timer; /* 前向声明 */
/* 绑定socket和定时器 */
struct client_data
{
    sockaddr_in address;
    int sockfd;
    char buf[BUFFER_SIZE];
    heap_timer* timer;
};

/* 定时器类 */
class heap_timer
{
public:
    explicit heap_timer(int delay)
    {
        expire = time(NULL) + delay;
    }
    time_t expire; /* 定时器生效的绝对时间 */
    void (*cb_func)(client_data*); /* 定时器的回调函数 */
    client_data* user_data; /* 用户数据 */
};

时间堆类time_heap

#include <iostream>
#include <netinet/in.h>
#include <time.h>
using std::exception;

/* 时间堆类 */
class time_heap
{
public:
    /* 构造函数之一, 初始化一个大小为cap的空堆 */
    time_heap(int cap) throw(std::exception) : capacity(cap), cur_size(0)
    {
        array = new heap_timer*[capacity]; /* 创建堆数组 */
        if (!array) {
            throw std::exception();
        }
        for (int i = 0; i < capacity; ++i) {
            array[i] = NULL;
        }
    }
    /* 构造函数之二, 用已有数组来初始化堆 */
    time_heap(heap_timer** init_array, int size, int cap) throw(std::exception)
    : cur_size(size), capacity(cap)
    {
        if (capacity < size) {
            throw std::exception();
        }
        array = new heap_timer*[capacity]; /* 创建堆数组 */
        if (!array) {
            throw std::exception();
        }
        for (int i = 0; i < capacity; ++i) {
            array[i] = NULL;
        }
        if (size != 0) {
            /* 初始化堆数组 */
            for (int i = 0; i < size; ++i) {
                array[i] = init_array[i];
            }
            for (int i = (cur_size - 1) / 2; i >= 0 ; ++i) {
                /* 对数组中第[(cur_size - 1)/2]~0个元素执行下虑操作 */
                percolate_down(i);
            }
        }
    }

    /* 销毁时间堆 */
    ~time_heap()
    {
        for (int i = 0; i < cur_size; ++i) {
            delete array[i];
        }
        delete[] array;
    }

    /* 添加目标定时器timer */
    void add_timer(heap_timer* timer) throw(std::exception)
    {
        if (!timer) {
            return;
        }
        if (cur_size >= capacity) { /* 如果当前数组容量不够, 则将其扩大一倍 */
            resize();
        }
        /* 新插入一个元素, 当前堆大小+1, hole是新建空穴的位置 */
        int hole = cur_size++;
        int parent = 0;
        /* 对从空穴到根节点的路径上的所有节点执行上虑操作 */
        for ( ; hole > 0; hole = parent) {
            parent = (hole - 1) / 2;
            if (array[parent]->expire <= timer->expire) {
                break;
            }
            array[hole] = array[parent];
        }
        array[hole] = timer;
    }

    /* 删除目标定时器timer */
    void del_timer(heap_timer* timer)
    {
        if (!timer) {
            return;
        }
        /* 仅仅将目标定时器的回调函数设置为空, 即所谓的延迟销毁.
         * 将节省真正删除该定时器造成的开销, 但这样容易使堆数组膨胀 */
        // FIXME: 删除定时器, 为何不重新调整堆?
        timer->cb_func = NULL;
    }

    /* 获得堆顶部的定时器 */
    heap_timer* top() const
    {
        if (empty()) {
            return NULL;
        }
        return array[0];
    }

    /* 删除堆顶部定时器 */
    void pop_timer()
    {
        if (empty()) {
            return;
        }
        if (array[0]) {
            delete array[0];
            /* 将原来堆顶元素替换为堆数组中最后一个元素 */
            array[0] = array[--cur_size];
            percolate_down(0); /* 对新的堆顶元素执行下虑操作 */
        }
    }

    /* 心搏函数 */
    void tick()
    {
        heap_timer* tmp = array[0];
        time_t cur = time(NULL); /* 循环处理堆中到期的定时器 */
        while (!empty()) {
            if (!tmp) {
                break;
            }
            /* 如果堆顶定时器没到期, 则退出循环 */
            if (tmp->expire > cur) {
                break;
            }
            /* 否则执行堆顶定时器中的任务 */
            if (array[0]->cb_func) {
                array[0]->cb_func(array[0]->user_data);
            }
            /* 将堆顶元素删除, 同时生成新的堆顶定时器(array[0]) */
            pop_timer();
            tmp = array[0];
        }
    }

    bool empty() const
    { return cur_size == 0; }

private:
    /* 最小堆的下虑操作, 它确保堆数组中以第hole个节点作为根的子树拥有最小堆性质 */
    void percolate_down(int hole)
    {
        heap_timer* temp = array[hole];
        int child = 0;
        for ( ; (hole * 2 + 1) <= (cur_size - 1); hole = child) {
            child = hole * 2 + 1;
            /* 找到hole子节点中最小节点child */
            if ((child < (cur_size - 1)) && (array[child + 1]->expire < array[child]->expire)) {
                ++child;
            }
            /* 交换hole, child位置对应元素, 以满足小堆特性 */
            if (array[child]->expire < temp->expire) {
                array[hole] = array[child];
            }
            /* 否则, 直接跳出继续找子节点的循环. 因为子树中不会存在不满足对特性的节点了 */
            else {
                break;
            }
        }
        /* 找到hole最终位置, 并赋值 */
        array[hole] = temp;
    }

    /* 将堆数组容量扩大1倍 */
    void resize() throw(std::exception)
    {
        heap_timer** temp = new heap_timer*[2 * capacity];
        for (int i = 0; i < 2 * capacity; ++i) {
            temp[i] = NULL;
        }
        if (!temp) {
            throw std::exception();
        }
        capacity = 2 * capacity;
        for (int i = 0; i < cur_size; ++i) {
            temp[i] = array[i];
        }
        delete[] array;
        array = temp;
    }

private:
    heap_timer** array; /* 堆数组 */
    int capacity; /* 堆数组容量 */
    int cur_size; /* 堆数组当前包含元素的个数 */
};

时间堆类的使用

提供time_heap::tick()的入口时间，不必是固定频率，只需要 <= 当前堆顶定时器的超时时间即可。

#include "time_heap.h"
#include <thread>
using namespace std;

void print(client_data* data)
{
    printf("%s\n", data->buf);
}

int main()
{
    time_heap th(20);
    for (int i = 8; i >= 0; --i) {
        int delay = i + 1;
        heap_timer* timer = new heap_timer(delay);
        timer->user_data = new client_data;
        snprintf(timer->user_data->buf, sizeof(timer->user_data->buf), "runs at %d sec", delay);
        timer->cb_func = print;
        th.add_timer(timer);
    }

    while (1) {
        th.tick();
        this_thread::sleep_for(chrono::milliseconds(100));
    }
    return 0;
}

参考

《Linux高性能服务器编程》