Linux下一种高效多定时器实现

最新推荐文章于 2024-04-27 01:33:13 发布
最新推荐文章于 2024-04-27 01:33:13 发布
阅读量1.3w 收藏 38
点赞数 6
文章标签： Linux 定时
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014026685/article/details/82180372
版权

Linux下一种高效多定时器实现

作者：LouisozZ

日期：2018.08.29

运行环境说明

由于在 Linux 系统下一个进程只能设置一个时钟定时器，所以当应用需要有多个定时器来共同管理程序运行时，就需要自行实现多定时器管理。

本文就是基于这种需求，在实际编码工作的基础上总结而出，希望跟大家共享，也欢迎大家讨论指正。

多定时器原理

在一个进程只能有一个定时器的前提条件下，想要实现多定时器，就得用到那个进程能利用的唯一的定时器，这个定时器是由操作系统提供的，通过系统提供的接口来设置，常用的有 alarm() 和 setitimer()，不论用什么，后文统一称作系统定时接口，这两个接口的区别在很多博客里都有，不怎么清楚的可以自行搜索，这里就不再赘述（我比较懒，打字多对肾不好）。通过它们产生的定时信号作为基准时间，来管理实现多定时器。

举个栗子，糖炒板栗。利用系统定时接口设置了基准定时器，基准定时器每秒产生一个 SIGALRM 信号（系统时钟的超时时间到了之后会向进程发送信号以通知定时超时，alarm() 和 setitimer() 都是向进程发送 SIGALRM 信号，关于 Linux ‘信号’ 的内容，可以参考 《UNIX环境高级编程》），产生两个 SIGALRM 信号的时间间隔，就是多定时器的基准时间。当然，上述的基准时间是一秒，如果你是每隔 50ms 产生一个 SIGALRM 信号，那么多定时器的基准时间就是 50ms 。当有了基准时间之后，就可以对它进行管理，可以设置多个定时任务，现有两个定时任务，Timer1_Task , Timer2_Task， 其中 Timer1_Task 的定时时长为 10 个基准时间，Timer2_Task 为 15 个基准时间，则每产生 10 个 SIGALRM 信号，就表示 Timer1_Task 定时器超时到达，执行一次 Timer1_Task 的超时任务，每产生 15 个 SIGALRM 信号，则执行一次 Timer2_Task 超时任务，当产生的 SIGALRM 信号个数是 30 （10 和 15 的最小公倍数），则 Timer1_Task 和 Timer2_Task 的超时任务都要被执行。

好了，原理讲完了，下面就是本文的重点了。

————————————— 说重点专用阉割线 —————————————

————————————— 说重点专用分割线 —————————————

高效多定时器

数据结构

由一个全局链表 g_pTimeoutCheckListHead 来管理超时任务。链表的每个节点是一个 tMultiTimer 结构体：

    typedef void TimeoutCallBack(void*);    //回调函数格式
    typedef struct tMultiTimer
    {
        uint8_t nTimerID;       //设置宏定义
        uint32_t nInterval;     //定时时长
        uint32_t nTimeStamp;    //时间戳
        bool bIsSingleUse;      //是否单次使用
        bool bIsOverflow;       //用于解决计数溢出问题

        TimeoutCallBack *pTimeoutCallbackfunction;  //回调函数
        void* pTimeoutCallbackParameter;            //回调函数参数

        struct tMultiTimer* pNextTimer;             //双向链表后驱指针
        struct tMultiTimer* pPreTimer;              //双向链表前驱指针
        struct tMultiTimer* pNextHandle;            //二维链表相同超时Timer节点
    }tMultiTimer;

    tMultiTimer* g_pTimeoutCheckListHead;           //管理多定时器的全局链表
    bool g_bIs_g_nAbsoluteTimeOverFlow;             //基准时间计次器溢出标志位
    uint32_t g_nAbsoluteTime;                       //基准时间计次器

（各个成员变量的意义在后文会逐一介绍，客官莫急）

这个是一个二维双向链表，第一维根据时间戳，即绝对时间，按照先后顺序连接每一个 tMultiTimer 节点，当有多个超时任务的超时时刻是相同的时候，只有一个节点位于第一维，其余接在上一个相同超时时刻 tMultiTimer 节点的 pNextHandle 上，图示如下：
这里写图片描述

多定时管理流程

超时检测与运行

首先需要调用系统定时接口，设置进程的定时器，产生 SIGALRM 信号，每一次 SIGALRM 到来时，全局的基准时间计次器 g_nAbsoluteTime 自加，由于 g_nAbsoluteTime 是无符号类型，当其溢出时，是回到 0 ，每次溢出就把 g_bIs_g_nAbsoluteTimeOverFlow 取反。

每个  tMultiTimer 节点都有 ：

    uint32_t nInterval;             //定时时长
    uint32_t nTimeStamp;        //时间戳

其中 nTimeStamp 这个值，是由 nInterval + g_nAbsoluteTime 计算而来，在把这个节点加入到全局链表的时刻计算的 ，这个和作为超时的绝对时间保存在结构体中，当计算的和溢出时，bIsOverflow 取反。通过这两个溢出标志位，可以用来解决溢出之后判断是否超时的问题，具体如下：

每一次基准时间超时，就检查链表的第一个节点的超时时间 nTimeStamp 是否小于全局绝对时间 g_nAbsoluteTime ，如果 g_bIs_g_nAbsoluteTimeOverFlow 与 bIsOverflow 不相等，则链表第一个节点的超时时间一定未到达，因为 bIsOverflow 的取反操作一定是先于 g_bIs_g_nAbsoluteTimeOverFlow ，如果一样则比较数值大小（初始化的时候两个溢出标志位是一样的）。当全局绝对时间大于等于第一个节点的时间戳，则把该节点及其 pNextHandle 指向的第二维链表取下，并更新 g_pTimeoutCheckListHead，然后依次执行所取下链表的回调函数。执行完之后（或者之前，根据实际情况定），判断 bIsSingleUse 成员变量，如果为 true 则表示是单次的计数器，仅执行一次，执行完回调之后则定时任务完成。如果是 false ，怎表示是定时任务，则重新执行一次添加超时任务。（添加超时任务看下一节）

添加超时任务

添加超时任务（添加一个 tMultiTimer 节点到全局链表 g_pTimeoutCheckListHead 中）的时候，指定超时时长，即间隔多少个基准时间，赋值给这个任务的成员变量 nInterval ，然后计算

    nTimeStamp = nInterval  + g_nAbsoluteTime; 
    if(nTimeStamp  < g_nAbsoluteTime) 
        bIsOverflow = ~bIsOverflow;

接着搜索 g_pTimeoutCheckListHead ，如果有相同时间戳，则添加到其 pNextHandle 指向位置，如果没有相同时间戳节点，找到比要插入的节点时间戳大的节点，然后把当前节点插入到其前方。

对于链表中已经有相同 ID 的 tMultiTimer 节点的情况，再次添加则表示更新该定时任务，取消之前的定时任务重新插入到链表中。

取消超时任务

直接把对应 ID 的 tMultiTimer 节点从 g_pTimeoutCheckListHead 链表中摘掉即可。

效率分析

g_pTimeoutCheckListHead 链表中的 tMultiTimer 节点数量，是总共设置的超时任务数量，假设为 n，添加一个超时任务（节点）的最坏情况是遍历 n 个节点。

检查是否有任务超时所用的时间是常数时间，只检查第一个节点。

对于定时任务的再次插入问题，如果定时任务间隔时间越短，其反复被插入的次数越多，但是由于定时时间短，所以在链表中的插入位置也就越靠前，将快速找到插入点；如果定时任务间隔时间越长，越可能遍历整个链表在末尾插入，但是由于间隔时间长，重复插入的频率则很低。

与一种简单的定时器实现相比较：

    if(g_nAbsoluteTime  %  4)
    {
        Timer_Task_1();
    }
    if(g_nAbsoluteTime  %  17)
    {
        Timer_Task_2();
    }

这种简单实现来说，

1：每次添加、取消一个定时任务都需要修改定时器源码，复用性不高。

2：每次检查是否有任务超时需要遍历 n 个定时任务。

关于多线程下的一些坑

我在实际项目中使用的环境是多线程的，有四个，我把多定时器管理放在了单独的一个线程里。由于系统定时器接口产生的信号是发送给进程的，所以所有的线程都共享这个闹钟信号。一开始我是这么想的，定时器的默认动作是杀死进程，那么给每个线程添加信号捕捉函数，这样的话闹钟信号到了之后不管是那个线程接管了，都能到我指定的处理函数去，可是实际情况并非如此，进程仍然会被杀死。

后面我用了线程信号屏蔽，把非定时器线程都设置了信号屏蔽字，即闹钟信号不被别的线程可见，这样才能正常运行，至于第一种方法为何不行，现在我还没有找到原因，还是对 Linux 的信号机制不熟，以后看有时间的话把这里搞懂吧。

main.c

    //配置信号集
    sigset_t g_sigset_mask;
    sigemptyset(&g_sigset_mask);
    sigaddset(&g_sigset_mask,SIGALRM);

other_thread.c

    sigset_t old_sig_mask;
    if(err = pthread_sigmask(SIG_SETMASK,&g_sigset_mask,&old_sig_mask) != 0)
    {
        // pthread_sigmask 设置信号屏蔽
        return ;
    }

mulitimer_thread

void* MultiTimer_thread(void *parameter)
{
    int err,signo;
    struct itimerval new_time_value,old_time_value;

    new_time_value.it_interval.tv_sec = 0;
    new_time_value.it_interval.tv_usec = 1000;
    new_time_value.it_value.tv_sec = 0;
    new_time_value.it_value.tv_usec = 1;
    setitimer(ITIMER_REAL, &new_time_value,NULL);

    for(;;)
    {
        err = sigwait(&g_sigset_mask,&signo);//信号捕捉
        if(err != 0)
        {
            return ;
        }

        if(signo == SIGALRM)
        {
            SYSTimeoutHandler(signo);
        }
    }
    return ((void*)0);
}

multiTimer.c

#include "multiTimer.h"

/**
 * @function    把一个定时任务添加到定时检测链表中
 * @parameter   一个定时器对象，可以由全局变量 g_aSPPMultiTimer 通过 TIMER_ID 映射得到
*/
static void AddTimerToCheckList(tMultiTimer* pTimer)
{
    tMultiTimer* pEarliestTimer = NULL;
    tMultiTimer* pEarliestTimer_pre = NULL;

    CDebugAssert(pTimer->nInterval != 0);

    pTimer->nTimeStamp = g_nAbsoluteTime + pTimer->nInterval;
    if(pTimer->nTimeStamp < g_nAbsoluteTime)
        pTimer->bIsOverflow = !(pTimer->bIsOverflow);
    if(g_pTimeoutCheckListHead == NULL)
    {
        g_pTimeoutCheckListHead = pTimer;
        g_pTimeoutCheckListHead->pNextTimer = NULL;
        g_pTimeoutCheckListHead->pPreTimer = NULL;
        g_pTimeoutCheckListHead->pNextHandle = NULL;
        return;
    }
    else
    {
        pEarliestTimer = g_pTimeoutCheckListHead;
        while(pEarliestTimer != NULL)
        {
            //如果超时时间小于新加的timer则直接跳过；
            if((pEarliestTimer->bIsOverflow != pTimer->bIsOverflow) || (pEarliestTimer->nTimeStamp < pTimer->nTimeStamp))
            {
                pEarliestTimer_pre = pEarliestTimer;
                pEarliestTimer = pEarliestTimer->pNextTimer;
            }    
            else
            {
                if(pEarliestTimer->nTimeStamp == pTimer->nTimeStamp)    //超时时刻相等，直接添加到相同时刻处理列表的列表头
                {
                    pTimer->pNextHandle = pEarliestTimer->pNextHandle;
                    pEarliestTimer->pNextHandle = pTimer;
                    return;
                }
                else                                                    //找到了超时时刻大于新加入timer的第一个节点
                {
                    if(pEarliestTimer->pPreTimer == NULL)               //新加入的是最早到达超时时刻的，添加到链表头
                    {
                        pEarliestTimer->pPreTimer = pTimer;
                        pTimer->pNextTimer = pEarliestTimer;
                        pTimer->pPreTimer = NULL;
                        pTimer->pNextHandle = NULL;
                        g_pTimeoutCheckListHead = pTimer;
                        return;
                    }
                    else                                                //中间节点
                    {
                        pEarliestTimer->pPreTimer->pNextTimer = pTimer;
                        pTimer->pNextTimer = pEarliestTimer;
                        pTimer->pPreTimer = pEarliestTimer->pPreTimer;
                        pEarliestTimer->pPreTimer = pTimer;
                        pTimer->pNextHandle = NULL;
                        return;
                    }
                }
            }  
        }
        if(pEarliestTimer == NULL)                                      //新加入的timer超时时间是最晚的那个
        {
            pEarliestTimer_pre->pNextTimer = pTimer;
            pTimer->pPreTimer = pEarliestTimer_pre;
            pTimer->pNextTimer = NULL;
            pTimer->pNextHandle = NULL;
        }
        return;
    }
}

/**
 * @function    设置一个定时任务，指定超时间隔与回调函数，当超时到来，自动执行回调
 * @parameter1  TIMER_ID    
 * @parameter2  超时间隔时间
 * @parameter3  是否是一次性定时任务
 * @parameter4  回调函数，注意，回调函数的函数形式  void function(void*);
 * @parameter5  void* 回调函数的参数，建议用结构体强转成 void*，在回调函数中再强转回来  
 * @return      错误码 
*/
uint8_t SetTimer(uint8_t nTimerID,uint32_t nInterval,bool bIsSingleUse,TimeoutCallBack* pCallBackFunction,void* pCallBackParameter)
{
    printf("\nset timer %d\n",nTimerID);
    tMultiTimer* pChoosedTimer = NULL;
    pChoosedTimer = g_aSPPMultiTimer[nTimerID];
    pChoosedTimer->nInterval = nInterval;
    pChoosedTimer->bIsSingleUse = bIsSingleUse;
    pChoosedTimer->pTimeoutCallbackfunction = pCallBackFunction;
    pChoosedTimer->pTimeoutCallbackParameter = pCallBackParameter;

    //如果超时任务链表中已经有这个任务了，先取消，然后再设置，即重置超时任务
    if(pChoosedTimer->pNextTimer != NULL || pChoosedTimer->pPreTimer != NULL)
        CancelTimerTask(nTimerID,CANCEL_MODE_IMMEDIATELY);

    AddTimerToCheckList(pChoosedTimer);
    return 0;
}

/**
 * @function    取消超时检测链表中的指定超时任务
 * @parameter1  要取消的超时任务的ID
 * @parameter2  模式选择，是立即取消，还是下次执行后取消
 * @return      错误码
*/
uint8_t CancelTimerTask(uint8_t nTimerID,uint8_t nCancelMode)
{
    printf("\ncancle timer %d\n",nTimerID);
    tMultiTimer* pEarliestTimer = NULL;
    tMultiTimer* pHandleTimer = NULL;
    tMultiTimer* pHandleTimer_pre = NULL;
    tMultiTimer* pChoosedTimer = NULL;

    pEarliestTimer = g_pTimeoutCheckListHead;
    pChoosedTimer = g_aSPPMultiTimer[nTimerID];

    if(nCancelMode == CANCEL_MODE_IMMEDIATELY)
    {
        while(pEarliestTimer != NULL)
        {
            pHandleTimer = pEarliestTimer;
            pHandleTimer_pre = NULL;
            while(pHandleTimer != NULL)
            {
                if(pHandleTimer->nTimerID == nTimerID)
                {
                    if(pHandleTimer_pre == NULL)
                    {
                        if(pHandleTimer->pNextHandle != NULL)
                        {
                            pEarliestTimer = pHandleTimer->pNextHandle;
                            pEarliestTimer->pPreTimer = pHandleTimer->pPreTimer;
                            if(pHandleTimer->pPreTimer != NULL)
                                pHandleTimer->pPreTimer->pNextTimer = pEarliestTimer;
                            pEarliestTimer->pNextTimer = pHandleTimer->pNextTimer;
                            if(pHandleTimer->pNextTimer != NULL)
                                pHandleTimer->pNextTimer->pPreTimer = pEarliestTimer;
                            pHandleTimer->pNextTimer = NULL;
                            pHandleTimer->pPreTimer = NULL;
                            pHandleTimer->pNextHandle = NULL;
                        }
                        else
                        {
                            if(pEarliestTimer->pPreTimer == NULL)
                            {
                                g_pTimeoutCheckListHead = pEarliestTimer->pNextTimer;
                                g_pTimeoutCheckListHead->pPreTimer = NULL;
                                pEarliestTimer->pNextTimer = NULL;
                            }
                            else if(pEarliestTimer->pNextTimer == NULL)
                            {
                                pEarliestTimer->pPreTimer->pNextTimer = NULL;
                                pEarliestTimer->pPreTimer = NULL;
                            }
                            else
                            {
                                pEarliestTimer->pPreTimer->pNextTimer = pEarliestTimer->pNextTimer;
                                pEarliestTimer->pNextTimer->pPreTimer = pEarliestTimer->pPreTimer;
                                pEarliestTimer->pPreTimer = NULL;
                                pEarliestTimer->pNextTimer = NULL;
                            }
                        }
                    }
                    else
                    {
                        pHandleTimer_pre->pNextHandle = pHandleTimer->pNextHandle;
                        pHandleTimer->pNextHandle = NULL;
                    }
                    return 0;
                }
                else
                {
                    pHandleTimer_pre = pHandleTimer;
                    pHandleTimer = pHandleTimer_pre->pNextHandle;
                }
            }
            pEarliestTimer = pEarliestTimer->pNextTimer;
        }
        #ifdef DEBUG_PRINTF
        printf("\nThere is no this timer task!\n");
        #endif
        return 2;   //出错，超时检测链表中没有这个超时任务
    }
    else if(nCancelMode == CANCEL_MODE_AFTER_NEXT_TIMEOUT)
    {
        pChoosedTimer->bIsSingleUse = true;
        return 0;
    }
    else
    {
        return 1;   //出错，模式错误，不认识该模式
    }
}
/**
 * @function    定时器处理函数，用于检测是否有定时任务超时，如果有则调用该定时任务的回调函数，并更新超时检测链表
 *              更新动作：如果超时的那个定时任务不是一次性的，则将新的节点加入到检测超时链表中，否则直接删掉该节点；
 * @parameter   
 * @return
*/
void SYSTimeoutHandler(int signo)
{
    //printf("\nenter SYSTimeoutHandler\n");
    if(signo != SIGALRM)
        return;
    tMultiTimer* pEarliestTimer = NULL;
    tMultiTimer* pWaitingToHandle = NULL;
    tMultiTimer* pEarliestTimerPreHandle = NULL;

    if(g_pTimeoutCheckListHead != NULL)
    {
        if((g_pTimeoutCheckListHead->nTimeStamp <= g_nAbsoluteTime) && (g_pTimeoutCheckListHead->bIsOverflow == g_bIs_g_nAbsoluteTimeOverFlow))
        {
            pWaitingToHandle = g_pTimeoutCheckListHead;
            g_pTimeoutCheckListHead = g_pTimeoutCheckListHead->pNextTimer;
            if(g_pTimeoutCheckListHead != NULL)
                g_pTimeoutCheckListHead->pPreTimer = NULL;
            pWaitingToHandle->pNextTimer = NULL;

            pEarliestTimer = pWaitingToHandle;
            while(pEarliestTimer != NULL)
            {
                pEarliestTimerPreHandle = pEarliestTimer;
                pEarliestTimer = pEarliestTimer->pNextHandle;
                pEarliestTimerPreHandle->pNextHandle = NULL;
                pEarliestTimerPreHandle->pNextTimer = NULL;
                pEarliestTimerPreHandle->pPreTimer = NULL;
                pEarliestTimerPreHandle->pTimeoutCallbackfunction(pEarliestTimerPreHandle->pTimeoutCallbackParameter);
                if(!(pEarliestTimerPreHandle->bIsSingleUse))
                    AddTimerToCheckList(pEarliestTimerPreHandle);
            }
        }
    }

    g_nAbsoluteTime++;
    if(g_nAbsoluteTime == 0)
        g_bIs_g_nAbsoluteTimeOverFlow = !g_bIs_g_nAbsoluteTimeOverFlow;

    return ;
}

void CancleAllTimerTask()
{
    tMultiTimer* pEarliestTimer = NULL;
    tMultiTimer* pHandleTimer = NULL;

    while(g_pTimeoutCheckListHead != NULL)
    {
        pEarliestTimer = g_pTimeoutCheckListHead;
        g_pTimeoutCheckListHead = g_pTimeoutCheckListHead->pNextTimer;

        while(pEarliestTimer != NULL)
        {
            pHandleTimer = pEarliestTimer;
            pEarliestTimer = pEarliestTimer->pNextHandle;

            pHandleTimer->pNextHandle = NULL;
            pHandleTimer->pNextTimer = NULL;
            pHandleTimer->pPreTimer = NULL;
            pHandleTimer->bIsOverflow = false;
        }
    }
    g_bIs_g_nAbsoluteTimeOverFlow = false;
    g_nAbsoluteTime = 0;
    return;
}

void MultiTimerInit()
{
    g_pTimeoutCheckListHead = NULL;
    g_bIs_g_nAbsoluteTimeOverFlow = false;
    g_nAbsoluteTime = 0;
    for(uint8_t index = 0; index < MAX_TIMER_UPPER_LIMIT; index++)
    {
        g_aSPPMultiTimer[index] = (tMultiTimer*)CMALLOC(sizeof(tMultiTimer));
        g_aSPPMultiTimer[index]->nTimerID = g_aTimerID[index];
        g_aSPPMultiTimer[index]->nInterval = g_aDefaultTimeout[index];
        g_aSPPMultiTimer[index]->nTimeStamp = 0;
        g_aSPPMultiTimer[index]->bIsSingleUse = true;
        g_aSPPMultiTimer[index]->bIsOverflow = false;
        g_aSPPMultiTimer[index]->pTimeoutCallbackfunction = NULL;
        g_aSPPMultiTimer[index]->pTimeoutCallbackParameter = NULL;
        g_aSPPMultiTimer[index]->pNextTimer = NULL;
        g_aSPPMultiTimer[index]->pPreTimer = NULL;
        g_aSPPMultiTimer[index]->pNextHandle = NULL;
    }
    /*  如果预先规定了一些定时器，这个时候可以初始化除时间戳以外的其他值  */
    //开启应答超时任务
    //OPEN_MULTITIMER_MANGMENT();
}

multiTimer.h

#ifndef __MULTITIMER_H__
#define __MULTITIMER_H__

#define MAX_TIMER_UPPER_LIMIT   6

#define TIMER_0                 0
#define TIMER_1                 1       //timer ID
#define TIMER_2                 2
#define TIMER_3                 3
#define TIMER_4                 4
#define TIMER_5                 5

#define CANCEL_MODE_IMMEDIATELY         0xf9
#define CANCEL_MODE_AFTER_NEXT_TIMEOUT  0x9f

typedef void TimeoutCallBack(void*);

//========================================================
//                      timer结构定义
//========================================================
typedef struct tMultiTimer
{
    uint8_t nTimerID;       //
    uint32_t nInterval;     //定时时长
    uint32_t nTimeStamp;    //时间戳
    bool bIsSingleUse;      //是否单次使用
    bool bIsOverflow;       //用于解决计数溢出问题
    TimeoutCallBack *pTimeoutCallbackfunction;
    void* pTimeoutCallbackParameter;

    //双向链表指针
    struct tMultiTimer* pNextTimer;
    struct tMultiTimer* pPreTimer;
    //相同时间戳的下一个处理函数    这里可能会有隐藏的 bug，如果基础时间中断比较快，那么可能在处理多个同一时间节点的
    //回调函数的时候被下一次的中断打断，这里会引起时序错误，
    //解决方案有三种，
    //一是可以人为避免，不设置有公约数的定时时间，这样的话同一个时刻有多个定时任务的情况就小很多；
    //二是回调函数尽量少做事，快速退出定时处理函数；
    //三是另开一个线程，这个线程仅把回调函数放到一个队列中，另一个线程持续从队列中取回调函数执行，这个是没有问题的方案，但是需要支持多线程或者多任务，并且需要注意加锁
    struct tMultiTimer* pNextHandle;

}tMultiTimer;

//========================================================
//               实现多定时任务的相关变量
//========================================================

tMultiTimer* g_pTimeoutCheckListHead;
bool g_bIs_g_nAbsoluteTimeOverFlow;
uint32_t g_nAbsoluteTime;

//========================================================
//                      外部接口
//========================================================
void MultiTimerInit();
uint8_t SetTimer(uint8_t nTimerID,uint32_t nInterval,bool bIsSingleUse,TimeoutCallBack* pCallBackFunction,void* pCallBackParameter);
uint8_t CancelTimerTask(uint8_t nTimerID,uint8_t nCancelMode);
void CancleAllTimerTask();
void SYSTimeoutHandler(int signo);
#endif
u014026685
关注
  • 6
    点赞
  • 踩
  • 38
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
linux C定时器：C语言定时器的使用
吻等离子的博客
09-23 2804
【代码】C语言定时器的使用。
Linux下多定时器的实现
彭令鹏(bripengandre)的专栏
07-28 4719
原文见：http://blog.chinaunix.net/u3/94771/showart_2000555.htmllinux下多定时器的实现一、已有的定时器接口   时空管理是计算机系统的主要任务。在时间管理中，我们经常利用定时器处理事情：比如tcp协议中利用定时器管理包超时，视频显示中利用定时器来定时显示视频帧，web服务中利用定时器来管理用户的超时。windows系统提供了Se
Linux多定时器实现
zdw6868的博客
07-25 1603
一、setitimer函数 1. 头文件 #include <sys/time.h> 2. 函数原型 int setitimer(int which, const struct itimerval *new_value, struct itimerval *old_value); which参数说明： ITIMER_REAL：给一个指定的时间间隔，按照实际的时间来减少这个计数，当时间间隔为0的时候发出SIGALRM信号； ITIMER_VIRTUA.
Linux下如何在一个进程中使用多个定时器
qq_57023986的博客
03-23 1125
原理利用select()方法的第5个参数，第一个参数设置为0，三个文件描述符集都设置为NULL，第5个参数为时间结构体，这种方法精度能够达到微妙级别，网上有很多基于select()的多线程定时器，说明select()稳定性还是非常好。问题描述：windows下的接口支持单进程中拥有多个定时器，而linux则只允许单进程拥有一个定时器，因此在linux下的单进程中要使用多个定时器，则需要自己维护管理。看APUE神书时候看到的，方法比较冷门，通过使用select()，来设置。
Linux环境下C++开发----4种定时任务方法
最新发布
Warren++的博客
04-27 847
Linux环境下C++开发----4种定时任务方法
linux编程之经典多级时间轮定时器(C语言版)
qq_40989769的博客
02-24 1426
上图是5个时间轮级联的效果图。中间的大轮是工作轮，只有在它上的任务才会被执行；其他轮上的任务时间到后迁移到下一级轮上，他们最终都会迁移到工作轮上而被调度执行。多级时间轮的原理也容易理解：就拿时钟做说明，秒针转动一圈分针转动一格；分针转动一圈时针转动一格；同理时间轮也是如此：当低级轮转动一圈时，高一级轮转动一格，同时会将高一级轮上的任务重新分配到低级轮上。从而实现了多级轮级联的效果。1.1 多级时间轮对象关于轮子上指针的位置有一个比较巧妙的办法：那就是位运算。
Linux: 定时器实现简析
JiMoKuangXiangQu的专栏
05-11 1163
Linux, timer
linux下多定时器的实现 经典
gftygff的博客
11-07 716
linux下多定时器的实现 经典
Linux下一种高性能定时器池的实现.pdf
09-06
时间轮是一种高效的定时任务管理方式，通过将定时器分配到虚拟时钟的槽位上，可以快速地找到即将到期的定时器。红黑树则是一种自平衡二叉查找树，可以确保插入、删除和查找操作的时间复杂度保持在O(log n)。将两者...
linux下自定义定时器的实现
08-29
在Linux操作系统中，自定义定时器...总结，Linux下自定义定时器的实现涉及到多个系统调用和编程技巧，包括信号处理、I/O复用和多线程同步。正确理解和使用这些工具，可以帮助开发者构建高效、可靠的定时任务处理系统。
linux 多线程安全定时器
08-16
`epoll`是Linux下的一种I/O多路复用技术，用于替代传统的`select`和`poll`。它能更有效地监控多个文件描述符，当这些描述符准备就绪时，`epoll_wait`会返回相应的事件。将`timerfd`与`epoll`结合，可以实现对定时器...
linux下的多定时器实现
08-25
文件列表：timer.h，timer.c 功能：实现了linux下的多定时器，采用双向链表来维护定时器列表，用户可利用其中的接口来创建定时器，并注册超时回调函数。时钟计时采用select系统调用来实现。
linux下定时器实现
01-29
时间轮是一种高效的时间管理算法，特别适用于大量定时器的场景。它由多个同心圆组成，每个圆代表一个时间槽，圆上的每个槽代表一个时间间隔。指针（或多个指针）围绕圆周移动，当指针经过某个槽时，对应的定时事件...
linux多定时器多线程
12-07
本文将深入探讨如何在Linux环境下利用多线程和多定时器来实现不同任务的并发执行，以及它们如何协同工作以提高程序效率。 一、Linux多线程 1. **线程定义**：线程是程序执行的最小单位，一个进程可以包含多个线程...
linux 定时器头文件,Linux多定时器实现
weixin_35939140的博客
04-28 637
一、setitimer函数1. 头文件#include2. 函数原型int setitimer(int which, const struct itimerval *new_value,struct itimerval *old_value);which参数说明：ITIMER_REAL：给一个指定的时间间隔，按照实际的时间来减少这个计数，当时间间隔为0的时候发出SIGALRM信号；ITIMER_V...
Linux C语言定时任务的实现
weixin_43055404的博客
08-27 4793
1. 前情提要 https://blog.csdn.net/zxl_1996/article/details/79138748 https://blog.csdn.net/sinat_36184075/article/details/80489402 http://www.voidcn.com/article/p-ybnmbawn-bgn.html 最近需要编写一个小的测试程序，在while循环中读取数据并且不间断的读取10分钟，10分钟之后就不再读取数据。一开始是想用一个很大的数来计数，每次循环减一，减到
Linux应用层的定时器简单实现
zhongcaogen的专栏
01-13 1368
Linux应用层的定时器简单实现
linux_设置定时器(C语言)-alarm函数-time命令-settimer函数
qq_44177918的博客
04-20 1683
返回0或剩余的秒数，此时剩余的秒数是：距离第一次调用alarm函数后第二次调用alarm函数，上一次设定的seconds定时没有执行完的时间。假设你上一次定时5s，但是你的程序执行2s后又再次调用该函数，则本次调用的返回值就是上一次定时剩余的时间3s。③ 运行时计时(用户+内核)：ITIMER_PROF → 27）SIGPROF 计算占用cpu及执行系统调用的时间。程序运行的瓶颈在于IO，优化程序，首选优化IO(标准输入输出屏幕)。常用：取消定时器alarm(0)，返回旧闹钟余下秒数。
c语言timer linux 回调函数_Linux下用C语言实现定时器
weixin_39966053的博客
01-17 1081
2020-02-22关键字：alarm()、setitimer()、拦截定时器信号、定时器信号有效范围在 Linux 中实现定时器功能的比较简单且好用的系统内置的方法有两种：1、alarm() 函数2、setitimer() 函数这两种定时方式都是通过信号(signal)来通知定时到期的。1、alarm() 函数实现定时功能alarm()函数的签名如下：#include unsignedint a...
linux下的sched头文件.docx
12-17
linux下的sched头文件.docx

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值