Linux高性能编程-时间轮-51CTO.COM

大家好，这里是物联网心球。

本期我们来聊聊时间轮，话不多说我们直接开始今天的主题。

1.初识时间轮

时间轮（TimingWheel）是一个环形队列，底层采用数组实现，数组中每个元素都是一个链表，链表中存储的是一个个定时任务。

定时任务可以分为：延时任务，周期性任务。

时间轮是一种非常重要的机制，通过时间轮可以轻松实现各种功能：

心跳机制。
周期性获取系统状态。
计时功能。
通知功能。
......

很多著名的开源软件都使用了时间轮，如：kafka，skynet，Linux内核等。

所以实现一个高效的时间轮对于我们的软件非常重要。

2.时间轮实现原理

2.1 时间轮整体架构

图片

时间轮主要由：时间轮盘，时间指针，定时任务，时间驱动器四部分组成。

1）时间轮盘

时间轮盘由固定数量槽位（wheelSize）构成，每个槽位对应一个时间跨度（tickMS），wheelSize*tickMS为时间轮最大时间跨度，定时任务的最大定时时间不能超过最高级时间轮的最大时间跨度。

定时任务的最小定时时间不能低于最低级时间轮的tickMS。

时间指针会记录时间轮的槽位位置，当时间指针指向一个槽位时，表示该槽位的任务链表中的任务需要被处理，如果当前时间到达任务的到期时间（expire time）则执行任务的回调函数，否则任务被重映射到上一级时间轮对应槽位。

2）时间指针

时间指针记录当前层级时间轮槽位位置，每一级时间轮的时间跨度不一样，各个层级的时间轮时间指针会存在一定的倍数关系（由用户自定义），低级时间轮时间指针转一周之后，上一级时间轮才会移动一个槽位。

3）定时任务

时间轮可以处理大批量定时任务，定时任务以链表的形式存储在每一个槽位，每个任务都由用户自定义功能，且每个任务都有到期时间和周期时间记录。

4）时间驱动器

时间驱动器就像电池一样，推动时间轮的运转，相当于一个定时刷新的功能模块。时间驱动器通常由一个单独的线程通过sleep或者其他超时机制实现。

2.2 从0到1实现一个时间轮

要实现一个高效的时间轮，我们得结合具体的业务确定：

每级时间轮时间跨度和大小
时间轮的层级数。
时间轮驱动器类型。

接着我们就可以完成时间轮盘，时间指针，定时任务，时间驱动器的设计。

本示例：

一级时间轮：时间跨度1秒，时间轮大小256。

二级时间轮：时间跨度256 * 1秒，时间轮大小256。

二级时间轮：时间跨度256 * 256 * 1秒，时间轮大小256。

时间驱动器：sleep和epoll可选。

2.2.1 组件设计

1）时间轮盘设计

struct tw {
    uint32_t tick_ms;
    uint32_t cur_tick;
    struct link slots[TW_LEVEL][TW_SIZE];
    pthread_spinlock_t lock;
};

时间轮盘定义了四个成员：

tick_ms：时间精度，最低级时间轮时间跨度。
cur_tick：当前时间，通过当前时间计算当前时间指针，确定定时任务所在槽位。
slots：槽位，用于存储定时任务，定时任务以单链表形式存储。TW_LEVEL：时间轮层级数。

TW_SIZE：时间轮大小（槽位数量）。

lock：自旋锁，保证多线程对任务链表的安全操作。

2）时间指针设计

时间指针按照时间轮的层级可以分为：一级时间指针，二级时间指针，三级时间指针，......。

代码设计并不一定要为每个时间指针定义一个变量，我们定义一个总的时间指针，总的时间指针通过位运算的获取每一级时间指针。

#define TW_BITS (8)
#define TW_SIZE (1 << TW_BITS) //单级时间轮大小（槽位数量）
#define TW_MASK (TW_SIZE - 1)

#define IDX0(data) data & TW_MASK;         //获取一级指针
#define IDX1(data) (data >> TW_BITS) & TW_MASK; //获取二级指针
#define IDX2(data) (data >> (2 * TW_BITS)) & TW_MASK;//获取三级指针

通过时间指针就能准确定位到时间轮盘上的槽位，找到对应的定时任务。

3）定时任务设计

图片

一个完整的定时任务，需要具备：任务类型，周期时间，到期时间，回调函数，回调函数参数等成员。

这样才能完成一次性任务，周期性任务，自定义任务等功能。

typedef void (*func)(void *arg);
struct tw_node {
    struct link link;
    int32_t expire_tick;
    int32_t period_ticks;
    int flags;
    func cb;
    void *arg;
};

link：单向链表节点，用于任务插入和移除操作。
expire_tick：定时任务到期时间，定时任务根据到期时间插入指定的槽位，并且更新时间轮时，根据到期时间决定任务是否被执行或者重映射。
period_ticks：周期性任务周期时间。
flags：任务类型，分为：一次性任务和周期性任务。

#define ONESHOT_FLAG 0x1 //一次性任务，只执行一次

#define PERIOD_FLAG 0x2 //周期性任务，周期性执行

cb：定时任务回调函数。
arg：定时任务回调函数参数。

4）时间驱动器设计

时间轮运转通过时间驱动器驱动，时间驱动器是周期性更新时间轮的机制。目前用的比较多的方法：sleep和epoll方法。

方法1：sleep方式

void *tw_driver_thread(void *arg) {
    struct tw *tw = (struct tw *)arg;
    while(1) {
        usleep(TICK_MS * 1000);
        tw_update(tw);
    }
}

sleep方法设计比较简单，while循环每一次循环调用usleep休眠指定的时间间隔（时间精度），休眠结束后更新时间轮指针。

方法二：epoll方式

void *tw_driver_thread(void *arg) {
    struct tw *tw = (struct tw *)arg;

    int efd = epoll_create(1024);
    if (efd == -1) {
        perror("epoll create error");
        return NULL;
    }
    struct epoll_event ev, events[MAX_EVENTS];

    while(1) {
        int nfds = epoll_wait(efd, events, MAX_EVENTS, TICK_MS);
        if (nfds == -1) {
            perror("epoll wait error");
            break;
        }

        tw_update(tw);

    }
}

epoll方式设计相对来说比较复杂，该方式借用epoll_wait超时机制实现精确定时，epoll方式除了定时之外，还可以借用epoll实现网络IO检测功能。

2.2.2 接口设计

时间轮重要接口定义：

// 1.初始化时间轮
void tw_init(struct tw *tw, uint32_t tick_ms);
// 2.释放时间轮
void tw_free(struct tw *tw);
// 3.添加定时任务
void tw_add(struct tw *tw, struct tw_node *node, bool 
nolock);
// 4.驱动时间轮
int tw_update(struct tw *tw);

其中tw_add和tw_update函数是难点和重点。

1）tw_add添加定时任务

图片

定时任务添加至时间轮首次到期时间=时间轮当前时间+任务延迟时间。

通过到期时间可以计算出每级时间轮的时间指针，定时任务插入优先级：三级时间轮>二级时间轮>一级时间轮。

周期性任务执行完后，需根据任务周期时间和当前时间重新计算到期时间，并根据到期时间再次将任务插入时间轮。

2）tw_update驱动时间轮

图片

时间驱动器后定时调用tw_update函数，tw_update每调用一次，时间轮的当前时间会增加1，根据当前时间获取到一级，二级，三级时间指针。

如果一级时间指针大于0，说明此时一级时间轮还没转够一周，该情况只需要处理一级时间指针指向的定时任务。

如果一级时间指针等于0，二级时间指针大于0，说明一级时间轮已经转了一周，此时处理二级时间指针指向定时任务。如果定时任务的过期时间和当前时间相等，则直接调用定时任务回调函数，如果不相等则将定时任务重新插入过期时间一级时间指针指向的槽位。

如果一级，二级时间指针都等于0，三级时间指针大于0，说明一级，二级时间轮都转了一周，此时需要处理三级时间指针指向的定时任务。如果定时任务的过期时间和当前时间相等，则直接调用定时任务回调函数，如果不相等则将定时任务重新插入过期时间二级时间指针指向的槽位。

3.时间轮测试

3.1 测试代码

测试代码是一份完整的时间轮代码，可以直接编译测试。

时间精度1秒，时间轮大小256，采用三级时间轮。

定时任务为英雄联盟剑圣技能冷却，每个技能都是一个延时任务：

Q技能：冷却时间14秒，持续时间1秒。
W技能：冷却时间35秒，持续时间5秒。
E技能：冷却时间14秒，持续时间5秒。
R技能：冷却时间75秒，持续时间10秒。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <stdbool.h>
#include <pthread.h>
#include <sys/time.h>
#include <sys/epoll.h>

#define TW_BITS (8)
#define TW_SIZE (1 << TW_BITS) //单级时间轮大小（槽位数量）
#define TW_MASK (TW_SIZE - 1)
#define TW_LEVEL (3) //时间轮层级数

#define IDX0(data) data & TW_MASK;
#define IDX1(data) (data >> TW_BITS) & TW_MASK;
#define IDX2(data) (data >> (2 * TW_BITS)) & TW_MASK;

#define ONESHOT_FLAG 0x1 //一次性任务
#define PERIOD_FLAG 0x2 //周期性任务

#define TICK_MS (1000) //单次延时时间，单位毫秒
#define MS_TO_TICKS(ms, tick_ms) (ms/tick_ms)

#define TW_DRIVER_TYPE (1) //时间驱动器类型
#define SLEEP_DRIVER (0) //sleep时间驱动器
#define EPOLL_DRIVER (1) //epoll时间驱动器

#define MAX_EVENTS (10)

struct link {
    struct link *next;
};

void link_init(struct link *link) {
    link->next = NULL;
}

void link_add(struct link *link, struct link *it) {
    it->next = link->next;
    link->next = it;
}

struct link *link_del(struct link *link) {
    if (!link->next) return NULL;
    struct link *it = link->next;
    link->next = it->next;
    return it;
}

typedef void (*func)(void *arg);
struct tw_node {
    struct link link;
    int32_t expire_tick;
    int32_t period_ticks;
    int flags;
    func cb;
    void *arg;
    bool need_free;
};

struct tw {
    uint32_t tick_ms;
    uint32_t cur_tick;
    struct link slots[TW_LEVEL][TW_SIZE];
    pthread_spinlock_t lock;
};

struct tw_node *tw_node_new(struct tw *tw, int expire_ms, int period_ms, int flags, func cb, void *arg, bool need_free) {
    if ((expire_ms < TICK_MS) || (period_ms < TICK_MS)) {
        return NULL;
    }

    struct tw_node *node = (struct tw_node*)malloc(sizeof(struct tw_node));
    if (!node) return NULL;
    memset(node, 0, sizeof(struct tw_node));
    node->expire_tick = MS_TO_TICKS(expire_ms, tw->tick_ms);
    node->period_ticks = MS_TO_TICKS(period_ms, tw->tick_ms);
    //printf("tw node new expire tick:%u,%u, peroid ticks:%u,%u\n", expire_ms, node->expire_tick, period_ms, node->period_ticks);
    node->flags = flags;
    node->cb = cb;
    node->arg = arg;
    node->need_free = need_free;
    return node;
}

void tw_node_free(struct tw_node *node) {
    if (node->arg && node->need_free) {
        uint32_t *task_id = (uint32_t *)node->arg;
        printf("free task id:%u node\n", *task_id);
        free(node->arg);
    }
    free(node);
}

void tw_init(struct tw *tw, uint32_t tick_ms) {
    memset(tw, 0, sizeof(struct tw));
    tw->tick_ms = tick_ms;
    pthread_spin_init(&tw->lock, PTHREAD_PROCESS_PRIVATE);
}

void tw_free(struct tw *tw) {

    pthread_spin_lock(&tw->lock);
    for (uint32_t i = 0; i < TW_LEVEL; i++) {
        for (uint32_t j = 0; j < TW_SIZE; j++) {
            struct link *link = &tw->slots[i][j];
            struct link *it;
            while(it = link_del(link)) {
                printf("free i:%u, j:%u\n", i, j);
                struct tw_node *node = (struct tw_node *)it;
                tw_node_free(node);
            }
        }
    }

    pthread_spin_unlock(&tw->lock);
    pthread_spin_destroy(&tw->lock);
}

void tw_add(struct tw *tw, struct tw_node *node, bool nolock) {

    if (!nolock) pthread_spin_lock(&tw->lock);

    uint32_t expire_tick = node->expire_tick;
    node->expire_tick += tw->cur_tick;

#if 0
    printf("tw add cur tick:%u, period ticks:%u, old expire tick:%u, node expire tick:%u\n",
            tw->cur_tick,
            node->period_ticks,
            expire_tick,
            node->expire_tick);
#endif

    uint8_t idx0 = IDX0(tw->cur_tick);
    uint8_t idx1 = IDX1(tw->cur_tick);
    uint8_t idx2 = IDX2(tw->cur_tick);

    uint8_t e0 = IDX0(node->expire_tick);
    uint8_t e1 = IDX1(node->expire_tick);
    uint8_t e2 = IDX2(node->expire_tick);
    //printf("tw add e0,e1,e2:%u,%u,%u\n", e0, e1, e2);

    struct link *it = &node->link;
    if (e2 != idx2) {
        struct link *link = &tw->slots[2][e2];
        //printf("tw link add 2,e2:%u\n", e2);
        link_add(link, it);
    } else if (e1 != idx1) {
        struct link *link = &tw->slots[1][e1];
        //printf("tw link add 1,e1:%u\n", e1);
        link_add(link, it);
    } else if (e0 != idx0){
        struct link *link = &tw->slots[0][e0];
        //printf("tw link add 0,e0:%u\n", e0);
        link_add(link, it);
    }

    if (!nolock) pthread_spin_unlock(&tw->lock);
}

int tw_update(struct tw *tw) {
    pthread_spin_lock(&tw->lock);
    tw->cur_tick++;
    uint8_t idx0 = IDX0(tw->cur_tick);
    uint8_t idx1 = IDX1(tw->cur_tick);
    uint8_t idx2 = IDX2(tw->cur_tick);
    struct link active = {0};
    if ((idx0 == 0) && (idx1 == 0) && (idx2 > 0)) {
        struct link *link = &tw->slots[2][idx2];
        struct link *it;
        while(it = link_del(link)) {
            //printf("tw update cur tick:%u, idx0:%u,idx1:%u,idx2:%u\n", tw->cur_tick, idx0, idx1, idx2);
            struct tw_node *node = (struct tw_node *)it;
            uint8_t e0 = IDX0(node->expire_tick);
            uint8_t e1 = IDX1(node->expire_tick);
            if ((e0 == 0) && (e1 == 0)) {
                link_add(&active, it);
            } else if (e1 > 0) {
                struct link *l = &tw->slots[1][e1];
                link_add(l, it);
            } else {
                struct link *l = &tw->slots[0][e0];
                link_add(l, it);
            }
        }
    } else if ((idx0 == 0) && (idx1 > 0)) {
        struct link *link = &tw->slots[1][idx1];
        struct link *it;
        while(it = link_del(link)) {
            //printf("tw update cur tick:%u, idx0:%u,idx1:%u,idx2:%u\n", tw->cur_tick, idx0, idx1, idx2);
            struct tw_node *node = (struct tw_node *)it;
            uint8_t e0 = IDX0(node->expire_tick);
            if (e0 == 0) {
                link_add(&active, it);
            } else {
                struct link *l = &tw->slots[0][e0];
                link_add(l, it);
            }
        }

    } else if (idx0 > 0) {
        struct link *link = &tw->slots[0][idx0];
        struct link *it;
        while(it = link_del(link)) {
            //printf("tw update cur tick:%u, idx0:%u,idx1:%u,idx2:%u\n", tw->cur_tick, idx0, idx1, idx2);
            link_add(&active, it);
        }
    }

    struct link *it;
    while(it = link_del(&active)) {
        struct tw_node *node = (struct tw_node *)it;
        //printf("tw update callback cur tick:%u@@\n", tw->cur_tick);
        node->cb(node->arg);
        if (node->flags & PERIOD_FLAG) {
            node->expire_tick = node->period_ticks;
            tw_add(tw, node, true);
        } else {
            tw_node_free(node);
        }
    }
    pthread_spin_unlock(&tw->lock);

    return 0;
}

void get_time(char *buffer) {
    struct timeval tv;
    gettimeofday(&tv, NULL);
    strftime(buffer, 40, "%Y-%m-%d %H:%M:%S", localtime(&tv.tv_sec));
    sprintf(buffer + strlen(buffer), ".%03ld", tv.tv_usec / 1000);
}

void *tw_driver_thread(void *arg) {
    struct tw *tw = (struct tw *)arg;

#if (TW_DRIVER_TYPE == EPOLL_DRIVER)
    int efd = epoll_create(1024);
    if (efd == -1) {
        perror("epoll create error");
        return NULL;
    }
    struct epoll_event ev, events[MAX_EVENTS];
#endif

    while(1) {
#if (TW_DRIVER_TYPE == SLEEP_DRIVER)
        usleep(TICK_MS * 1000);
        tw_update(tw);
        //printf("sleep driver\n");
#else
        int nfds = epoll_wait(efd, events, MAX_EVENTS, TICK_MS);
        if (nfds == -1) {
            perror("epoll wait error");
            break;
        }

        //printf("epoll driver nfds:%d\n", nfds);
        tw_update(tw);
#endif
    }
}

struct skill {
    char skill_name[20];
    char ch;
    int cool_time;
    int duration_time;
    bool ready;
};

struct hero {
    char hero_name[20];
    struct skill Q;
    struct skill W;
    struct skill E;
    struct skill R;
};

void skill_task(void *arg) {
    struct skill *sk = (struct skill *)arg;
    sk->ready = true;
    char buf[40] = {0};
    get_time(buf);
    printf("%s %s 完成冷却!\n", buf, sk->skill_name);
}

void *task_scheduler_thread(void *arg) {
    struct tw *tw = (struct tw *)arg;
    struct hero yi = (struct hero) {
        .hero_name = "易大师",
            .Q = {.skill_name = "Q技能", .ch = 'q', .cool_time = 14, .duration_time = 1, .ready = true},
            .W = {.skill_name = "W技能", .ch = 'w', .cool_time = 35, .duration_time = 5, .ready = true},
            .E = {.skill_name = "E技能", .ch = 'e', .cool_time = 14, .duration_time = 5, .ready = true},
            .R = {.skill_name = "R技能", .ch = 'r', .cool_time = 75, .duration_time = 10, .ready = true},
    };

    while(1) {
        int ch = getchar();
        if (ch == '\n') continue;
        switch (ch) {
            case 'q':
                if (yi.Q.ready == false) {
                    printf("%s %s 冷却中......\n", yi.hero_name, yi.Q.skill_name);
                } else {
                    char buf[40] = {0};
                    get_time(buf);
                    printf("%s %s 施放 %s QQQQQQQQQQQQQQQ\n", buf, yi.hero_name, yi.Q.skill_name);
                    yi.Q.ready = false;
                    struct tw_node *node = tw_node_new(tw, yi.Q.cool_time * 1000, 1000, ONESHOT_FLAG, skill_task, (void *)&yi.Q, false);
                    if (!node) {
                        printf("tw node new error\n");
                        break;
                    }
                    tw_add(tw, node, false);
                }
                break;
            case 'w':
                if (yi.W.ready == false) {
                    printf("%s %s 冷却中......\n", yi.hero_name, yi.W.skill_name);
                } else {
                    char buf[40] = {0};
                    get_time(buf);
                    printf("%s %s 施放 %s WWWWWWWWWWWWWW\n", buf, yi.hero_name, yi.W.skill_name);
                    yi.W.ready = false;
                    struct tw_node *node = tw_node_new(tw, yi.W.cool_time * 1000, 1000, ONESHOT_FLAG, skill_task, (void *)&yi.W, false);
                    if (!node) {
                        printf("tw node new error\n");
                        break;
                    }
                    tw_add(tw, node, false);
                }
                break;
            case 'e':
                if (yi.E.ready == false) {
                    printf("%s %s 冷却中......\n", yi.hero_name, yi.E.skill_name);
                } else {
                    char buf[40] = {0};
                    get_time(buf);
                    yi.E.ready = false;
                    printf("%s %s 施放 %s EEEEEEEEEEEEEE\n", buf, yi.hero_name, yi.E.skill_name);
                    struct tw_node *node = tw_node_new(tw, yi.E.cool_time * 1000, 1000, ONESHOT_FLAG, skill_task, (void *)&yi.E, false);
                    if (!node) {
                        printf("tw node new error\n");
                        break;
                    }
                    tw_add(tw, node, false);
                }
                break;
            case 'r':
                if (yi.R.ready == false) {
                    printf("%s %s 冷却中......\n", yi.hero_name, yi.R.skill_name);
                } else {
                    char buf[40] = {0};
                    get_time(buf);
                    printf("%s %s 施放 %s RRRRRRRRRRRRRRR\n", buf, yi.hero_name, yi.R.skill_name);
                    yi.R.ready = false;
                    struct tw_node *node = tw_node_new(tw, yi.R.cool_time * 1000, 1000, ONESHOT_FLAG, skill_task, (void *)&yi.R, false);
                    if (!node) {
                        printf("tw node new error\n");
                        break;
                    }
                    tw_add(tw, node, false);
                }
                break;
            default:
                printf("xxx无效技能:%c\n", ch);
                break;
        }
    }

    return NULL;
}

int main(int argc, char *argv[]) {

    struct tw tw;
    tw_init(&tw, TICK_MS);

    pthread_t th1;
    pthread_create(&th1, NULL, task_scheduler_thread, (void *)&tw);
    pthread_t th2;
    pthread_create(&th2, NULL, tw_driver_thread, (void *)&tw);

    pthread_join(th1, NULL);
    pthread_join(th2, NULL);

    printf("start free timewheel\n");

    tw_free(&tw);

    return 0;
}

3.2 测试结果

图片

总结：

时间轮可以处理大批量延时任务和周期性任务，是非常实用的一个软件模块，小伙伴可以自己动手实现一个时间轮。