自己实现一个定时器

已于 2022-08-30 21:28:17 修改
阅读量85 收藏
点赞数
分类专栏： 小组件 文章标签： 链表 数据结构 c++ 算法 linux
于 2022-08-30 21:27:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45826058/article/details/126612784
版权

目录

问题引入

  • 如果要写一个完整的项目，一个可靠的定时器是不可或缺的，先实现一个简单的定时器，以后再慢慢完善。

介绍

  • 基于 alarm() 发出 SIGALRM 信号驱动定时器运作
  • 使用双向链表存储数据节点信息

代码

目录结构

01

double_llist.h

#ifndef DOUBLE_LLIST__
#define DOUBLE_LLIST__

typedef void d_llist_node_t;
typedef void d_llist_t;

int llist_init(d_llist_t **llist);

typedef int (*compare)(void *a, void *b);
int llist_insert(d_llist_t *llist, void *key, compare cmp);

d_llist_node_t *llist_pop_first(d_llist_t *llist);
d_llist_node_t *llist_pop_last(d_llist_t *llist);

d_llist_node_t *llist_head_look(d_llist_t *llist);
d_llist_node_t *llist_tail_look(d_llist_t *llist);

int llist_destroy(d_llist_t *llist);

typedef int (*traver)(void *node);
int llist_traver(d_llist_t *llist, traver tvr);

// typedef int (*compare)(void *a, void *b);
int llist_check(d_llist_t *llist, compare cmp);

// new
d_llist_node_t *llist_find_node(d_llist_t *llist, void *key, compare cmp);

int llist_delete_node(d_llist_t *llist, void *key, compare cmp);

#endif

double_llist.c

#include <stdio.h>
#include <stdlib.h>

#include "./double_llist.h"


typedef struct llist_node_s{

    void *key;
    struct llist_node_s *prev;
    struct llist_node_s *next;

}llist_node_t;

typedef struct llist_s{

    llist_node_t *head;
    llist_node_t *tail;

}llist_t;




int llist_init(void **llist){

    llist_t *me = NULL;

    me = (llist_t*)malloc(sizeof(*me));
    if(me == NULL){
        return -1;
    }

    me->head = NULL;
    me->tail = NULL;

    *llist = me;

    return 0;
}

/*
    typedef int (*compare)(void *a, void *b);
    compare return value:
        1 : a > b
        -1 : a < b
        0 : a == b
*/
int llist_insert(d_llist_t *llist, void *key, compare cmp){

    llist_t *me = llist;
    llist_node_t *cur = me->head;
    llist_node_t *node_ = NULL;

    node_ = (llist_node_t*)malloc(sizeof(*node_));
    if(node_ == NULL){
        return -1;
    }
    node_->next = NULL;
    node_->prev = NULL;
    node_->key = key;

    int res = 0;

    while(cur != NULL){

        res = cmp(key, cur->key);
        if(res > 0){
            cur = cur->next;
        }else{  // res < 0 || res == 0
            break;
        }

    }


    if(cur == NULL){
        // insert on tail
        // or head = tail = NULL, llist is null
        node_->prev = me->tail;
        node_->next = NULL;
        if(me->tail != NULL){
            me->tail->next = node_;
            me->tail = node_;
        }else{
            me->tail = node_;
        }
        if(me->head == NULL){
            me->head = node_;
        }

    }else if(cur == me->head){
        // insert on head
        node_->next = me->head;
        node_->prev = NULL;
        me->head->prev = node_;
        me->head = node_;

    }else{

        node_->next = cur;
        node_->prev = cur->prev;
        cur->prev->next = node_;
        cur->prev = node_;

    }

    return 0;
}

void *llist_pop_first(void *llist){

    llist_t *me = llist;
    llist_node_t *cur = me->head;

    if(cur == NULL){

        return NULL;

    }else if(cur->next == NULL){

        me->head = NULL;
        me->tail = NULL;

    }else{

        me->head = cur->next;
        me->head->prev = NULL;

    }

    void *ret = cur->key;

    free(cur);

    return ret;
}

void *llist_pop_last(void *llist){

    llist_t *me = llist;
    llist_node_t *cur = me->tail;

    if(cur == NULL){
        return NULL;
    }else if(cur->prev == NULL){
        me->head = NULL;
        me->tail = NULL;
    }else{
        me->tail = cur->prev;
        me->tail->next = NULL;
    }


    void *ret = cur->key;

    free(cur);

    return ret;
}

int llist_destroy(void *llist){

    llist_t *me = llist;
    llist_node_t *cur = me->head, *temp = NULL;

    while(cur != NULL){

        temp = cur->next;

        free(cur->key);
        free(cur);

        cur = temp;

    }

    free(me);

    llist = NULL;

    return 0;
}

/*
typedef int (*traver)(void *node);
*/
int llist_traver(void *llist, traver tvr){

    llist_t *me = llist;
    llist_node_t *cur = me->head;

    while(cur != NULL){

        tvr(cur->key);

        cur = cur->next;
        if(cur){
            printf(" -> ");
        }
    }
    printf("\n");

    return 0;
}


int llist_check(void *llist, compare cmp){

    llist_t *me = llist;
    llist_node_t *cur = me->head;

    if(cur != NULL && cur->next != NULL){
        cur = cur->next;
    }else{
        return 0;
    }

    while(cur != NULL){

        if(cmp(cur->key, cur->prev->key) < 0){
            return -1;
        }
        cur = cur->next;

    }

    return 0;
}




d_llist_node_t *llist_head_look(d_llist_t *llist){

    llist_t *me = llist;

    if(me->head == NULL){
        return NULL;
    }

    return me->head->key;
}
d_llist_node_t *llist_tail_look(d_llist_t *llist){

    llist_t *me = llist;

    if(me->tail == NULL){
        return NULL;
    }

    return me->tail->key;
}


// new
d_llist_node_t *llist_find_node(d_llist_t *llist, void *key, compare cmp){

    llist_t *me = llist;
    llist_node_t *cur = me->head;
    int res = 0;

    

    while(1){
        if (cur == NULL){
            return NULL;
        }

        res = cmp(key, cur->key);
        if(res == 0){
            return cur;
        }

        cur = cur->next;
    }


    return NULL;
}

int llist_delete_node(d_llist_t *llist, void *key, compare cmp){

    llist_t *me = llist;
    llist_node_t *cur = llist_find_node(llist, key, cmp);

    if(cur == NULL){
        return -1;
    }

    if(cur->prev == NULL && cur->next == NULL){

        me->head = NULL;
        me->tail = NULL;
        
    }else if(cur->prev == NULL){
        me->head = cur->next;
        me->head->prev = NULL;
    }else if(cur->next == NULL){
        me->tail = cur->prev;
        me->tail->next = NULL;
    }else{
        cur->next->prev = cur->prev;
        cur->prev->next = cur->next;
    }

#if 1
    free(cur->key);
    free(cur);
#endif

    return 0;
}

timer.h

#ifndef _TIMER_H__
#define _TIMER_H__


// 定时器触发后的回调函数
typedef int (*callback)(void *);

typedef struct mytimer_st{

    d_llist_t *llist;
    time_t timeslot;
    int start;

    time_t pass;

}mytimer_t;

typedef struct timer_msg_st{

    time_t expire;
    int isloop;
    callback cb;
    void *arg;

}timer_msg_t;



int mytimer_init_timer(mytimer_t **timer, time_t timeslot);

int mytimer_start(mytimer_t *timer);

int mytimer_add_timer(mytimer_t *timer, time_t expire, int isloop, callback cb, void *arg);

typedef int (*compare_user)(void *a, void *b);
int mytimer_adjust_timer(mytimer_t *timer, void *key, time_t new_expir, int new_isloop, callback new_cb, void *new_age, compare_user cmp);

int mytimer_del_timer(mytimer_t *timer, void *key, compare_user cmp);

int mytimer_destroy_timer(mytimer_t *timer);


#endif

timer.c

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <signal.h>

#include "../double_llist/double_llist.h"
#include "./timer.h"


static mytimer_t *for_signal_handler = NULL;


static int mycompare_expire(void *a, void *b){

    timer_msg_t *x = a;
    timer_msg_t *y = b;

    return (x->expire) - (y->expire);
}

static int tick(void){

    mytimer_t *me = for_signal_handler;
    timer_msg_t *node = NULL;

    me->pass += me->timeslot;

    while(1){
        node = llist_head_look(me->llist);
        if(node == NULL){
            break;
        }

        if(node->expire <= me->pass){
            node->cb(node->arg);
            node = llist_pop_first(me->llist);
            if(node->isloop != 0){
                node->expire = me->pass + node->isloop;
                llist_insert(me->llist, node, mycompare_expire);
            }else{
                free(node);
            }
        }else{
            break;
        }


    }

    return 0;
}

static void signal_handler(int signo){


    tick();

    printf(".");
    fflush(stdout);

    alarm(for_signal_handler->timeslot);

    return ;
}


int mytimer_init_timer(mytimer_t **timer, time_t timeslot){

    mytimer_t *me = (mytimer_t*)malloc(sizeof(*me));
    if(me == NULL){
        return -1;
    }

    int ret;

    ret = llist_init(&(me->llist));
    if(ret){
        return -1;
    }

    me->timeslot = timeslot;
    me->start = 0;
    me->pass = 0;

    *timer = me;
    for_signal_handler = me;

    signal(SIGALRM, signal_handler);

    return 0;
}

static int set_alarm(int sec){

    alarm(sec);

    return 0;
}

int mytimer_start(mytimer_t *timer){

    mytimer_t *me = timer;

    if(me->start == 0){
        me->start = 1;
        set_alarm(me->timeslot);
    }

    return 0;
}

int mytimer_add_timer(mytimer_t *timer, time_t expire, int isloop, callback cb, void *arg){

    mytimer_t *me = timer;
    timer_msg_t *willAdd = (timer_msg_t*)malloc(sizeof(*willAdd));
    if(willAdd == NULL){
        return -1;
    }

    willAdd->expire = expire + me->pass;
    willAdd->cb = cb;
    willAdd->arg = arg;
    if(isloop == 1){
        willAdd->isloop = expire;
    }

    int ret = llist_insert(me->llist, willAdd, mycompare_expire);
    if(ret){
        return -2;
    }

    return 0;
}

// typedef int (*compare_user)(void *a, void *b);
int mytimer_adjust_timer(mytimer_t *timer, void *key,
                         time_t new_expir, int new_isloop, callback new_cb, void *new_age, compare_user cmp){
    
    mytimer_t *me = timer;
    int res = 0;

    res = llist_delete_node(me->llist, key, cmp);
    if(res){
        return -2;
    }

    timer_msg_t *node = (timer_msg_t*)malloc(sizeof(*node));
    if(node == NULL){
        return -1;
    }

    node->expire = new_expir + me->pass;
    if(new_isloop == 1){
        node->isloop = new_expir;
    }
    node->cb = new_cb;
    node->arg = new_age;

    return llist_insert(me->llist, node, mycompare_expire);
}

// typedef int (*compare_user)(void *a, void *b);
int mytimer_del_timer(mytimer_t *timer, void *key, compare_user cmp){

    mytimer_t *me = timer;
    int res = 0;

    res = llist_delete_node(me->llist, key, cmp);
    if(res){
        return -1;
    }

    return 0;
}

int mytimer_destroy_timer(mytimer_t *timer){

    mytimer_t *me = timer;
    
    llist_destroy(me->llist);
    free(me);

    timer = NULL;

    return 0;
}

test.c

#include <stdio.h>
#include <stdlib.h>

#include <unistd.h>

#include "../double_llist/double_llist.h"
#include "./timer.h"


// typedef int (*callback)(void *);

int my_callback(void *arg){

    char *data = arg;

    printf("[%d]Hello World!\n", atoi(data));

    return 0;
}

int my_compare(void *a, void *b){

    // timer_msg_t *A = a;
    timer_msg_t *B = b;

    char *x = a;
    char *y = B->arg;

    int x_ = atoi(x);
    int y_ = atoi(y);

    return x_ - y_;
}

int mytraver(void *a){

    timer_msg_t *msg = a;

    printf("[%ld : %d]", msg->expire, atoi(msg->arg));

    return 0;
}

int main(){

    mytimer_t *timer = NULL;
    int timeslot = 1;
    int ret = 0;

    ret = mytimer_init_timer(&timer, timeslot);
    if(ret){
        printf("init_timer() error!\n");
        exit(1);
    }

    mytimer_start(timer);

    mytimer_add_timer(timer, 2, 1, my_callback, "2");
    mytimer_add_timer(timer, 3, 1, my_callback, "3");
    mytimer_add_timer(timer, 5, 0, my_callback, "5");
    mytimer_add_timer(timer, 10, 1, my_callback, "10");
    mytimer_add_timer(timer, 30, 1, my_callback, "30");

    llist_traver(timer->llist, mytraver);

    // mytimer_del_timer(timer, "2", my_compare);
    // mytimer_del_timer(timer, "10", my_compare);

    int i = 0;
    while(1){
        if(i == 10){
            mytimer_adjust_timer(timer, "2", 6, 1, my_callback, "6", my_compare);
        }
        pause();
        i++;
    }


    mytimer_destroy_timer(timer);

    exit(0);
}

总结

已实现功能

  1. 添加定时任务 / 循环任务
  2. 修改定时任务
  3. 删除定时任务

待实现功能

  1. 可以将数据结构再优化调整。
remoter.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Jquery实现定时器实例
猿小白的博客
09-23 3412
目录 一、实例代码 二、运行结果 一、实例代码 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Jquery实现定时器案例</title> <style> #demo { width: 300px; margin: 10% auto;
使用Java实现一个定时器
qq_63691275的博客
10-03 5988
java.util.Timer类： 它是一种工具，线程用其安排以后在后台线程中执行的任务，可安排任务执行一次，或者定期重复执行； 其构造方法： Timer() 创建一个新计时器 Timer(boolean isDaemon) 创建的该计时器可以指定相关的线程作为守护线程运行。 我们需要用到的方法： void schedule(TimerTask task,Date firstTime,long period) （看参数大概也可以知道功能）安排指定任务在指定时间开始进行重复执行
c语言定时器的实现,C语言实现简单的定时器
weixin_39638309的博客
05-19 5790
本文实例为大家分享了C语言实现简单的定时器的具体代码，供大家参考，具体内容如下1.代码分析2.代码#include #include #include #ifndef CLOCKS_PER_SEC#define CLOCKS_PER_SEC 1000#endifint main( void ){clock_t start;long count = 1;start = clock();while(1...
python实现定时器
小胖_@的博客
10-17 2万+
文章目录python实现定时器1. 使用time，threading 模块2. 使用datetime，threading 模块3. 使用time，schedule 模块 （执行单个任务）4. 使用time，schedule 模块 （执行多个任务）时间有冲突的执行多个任务多线程并发运行多个任务5. 使用apscheduler 模块apscheduler 模块详情介绍代码实现 python实现定时器 ......
C++实现定时器
MaxMaxXiong的博客
08-27 1万+
定时器的主要数据： 1.一个线程变量，保存定时器线程 2.一个互斥锁，配合条件变量使用 3.一个条件变量，结合互斥锁，可以是线程不执行任务时，睡眠一段时间，在退出调用时，可以唤醒线程完成退出 4.定时执行函数，具体的定时执行业务操作 5.间隔时间，定时器间隔一段时间调用定时执行函数 6.一个退出标识，标志是否退出定时线程循环 7.立即执行标识，标识新建状态的定时线程是否立即执行一次任务，而不需等待一个间隔时间才开始执行第一次任务 #include <ios...
android之几种定时器实现
热门推荐
lizhong
09-10 4万+
在android中，经常用到的定时器主要有以下几种实现： 一、采用Handler与线程的sleep(long )方法 二、采用Handler的postDelayed(Runnable, long) 方法 三、采用Handler与timer及TimerTask结合的方法。 详细介绍： 一、采用Handle与线程的sleep(long )方法 Handler主要用来处理接受到的消息。这只是...
C#：用Stopwatch实现一个精准定时器
我爱学习，学习爱我
06-24 1707
之前一直用winform自带的Timer定时器，简单好用，但有一个小缺点，间隔时刻不是很精准，这强迫症肯定不能接受，所以用Stopwatch写了个计时器类，运行稳定后精度能稳定在毫秒级。
如何用c 语言写一个 定时器
weixin_43225966的博客
10-23 7363
1.代码分析 2.代码 #include <stdio.h> #include <time.h> #include <conio.h> #ifndef CLOCKS_PER_SEC #define CLOCKS_PER_SEC 1000 #endif int main( void ) { clock_t start; long count = 1; start = clock(); while(1) { if((clock() - start) ==
C语言实现定时器
RToax
08-11 6268
目录 timer.h timer.c timer.h #ifndef __TIMER_H #define __TIMER_H 1 #include <sys/time.h> #include <stdbool.h> #include "list.h" struct timer_node { unsigned long int timerid; struct timeval timeout; struct timeval interva
51单片机实现用一个定时器输出可调PWM
weixin_56337907的博客
04-13 3897
51单片机实现用一个定时器输出可调PWM
一个定时器实现多个虚拟定时器具体代码实现
03-23
一个定时器实现多个虚拟定时器具体代码实现
一个高效的定时器分析及设计
01-20
对于一个游戏而言，定时器是必须的，而它一般作为一个游戏基本公共组件，而定时器在游戏逻辑中运用是非常明显的(比如吃药回血，每几秒回血多少)，而对于游戏逻辑而言需要开发一个高效率高精度(毫秒级别)的定时器。...
用golang实现一个定时器任务队列实例
01-03
很有幸得到公司信任，采用新的语言进行一些底层服务的开发，在实现功能的同时，也获得了一些感悟，因此在这记录一下，方便自己查看也可以共享给大家。 golang中定时器 golang中提供了2种定时器timer和ticker（如果...
Java实现一个简单的定时器代码解析
08-28
主要介绍了Java实现一个简单的定时器代码解析，具有一定借鉴价值，需要的朋友可以参考下。
数据结构——bitset（位图）模拟实现
mastershooter的博客
06-11 603
第一种：构造一个8位的位图，所有为初始化为0//00000000第二种：构造一个8位的位图，根据所给的值初始化位图前N位//01100100第三种：构造一个8位的位图，根据字符串中的0/1序列来初始化位图的前N位//00111001。
Python基础教程（十一）：数据结构汇总梳理
菜鸟小码的博客
06-11 1168
本文将深入探讨Python中的主要数据结构类型，包括列表（List）、元组（Tuple）、字典（Dictionary）和集合（Set），并通过具体案例来展示它们的应用场景。
【排序算法】总结篇
SWsunlight的博客
06-08 941
排序对比
树1----7-3 列出叶结点
Steve_hhh的博客
06-08 212
首先第一行给出一个正整数 n（≤10），为树中结点总数。树中的结点从 0 到 n−1 编号。随后 n 行，每行给出一个对应结点左右孩子的编号。如果某个孩子不存在，则在对应位置给出 "-"。编号间以 1 个空格分隔。在一行中按规定顺序输出叶结点的编号。编号间以 1 个空格分隔，行首尾不得有多余空格。对于给定的二叉树，本题要求你按从上到下、从左到右的顺序输出其所有叶结点。
数据结构下的线性回归模型
最新发布
qq_35320456的博客
06-11 602
线性回归是一种强大的统计工具，它可以帮助我们理解和预测数据之间的关系。通过使用适当的数据结构，我们可以有效地构建和训练线性回归模型，从而对新的输入进行准确的预测。在实际应用中，我们需要根据问题的具体情况进行适当的模型调整和优化，以获得最佳的结果。在本文中，我们介绍了线性回归模型的基本概念、原理以及如何在C#中实现一个简单的线性回归模型。通过示例代码，我们展示了如何使用数据结构来存储和处理数据，以及如何训练模型并进行预测。希望这篇博客能够帮助你更好地理解线性回归模型及其在实际中的应用。
Linux下C++实现一个定时器
05-30
要在Linux下实现一个定时器，可以使用以下两种方法： 1. 使用系统提供的定时器API Linux系统提供了一些定时器API，如setitimer、timer_create、timer_gettime等，可以使用这些API来实现定时器。以setitimer为例，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值