Linux下多定时器的实现

最新推荐文章于 2023-05-11 16:26:38 发布
最新推荐文章于 2023-05-11 16:26:38 发布
阅读量3.6k 收藏 4
点赞数
分类专栏： Linux/Unix/BSD

原文地址：http://blog.csdn.net/bripengandre/article/details/4388417

linux下多定时器的实现
一、已有的定时器接口
    时空管理是计算机系统的主要任务。在时间管理中，我们经常利用定时器处理事情：比如tcp协议中利用定时器管理包超时，视频显示中利用定时器来定时显示视频帧，web服务中利用定时器来管理用户的超时。windows系统提供了SetTimer和timeSetEvent等定时器接口，linux中则提供了setitimer等接口。这些函数的接口很类似，大体上都是用户提供回调函数和超时时间向OS注册一个定时器事件，OS在超时时间到了的时候，调用用户提供的回调函数来完成用户想要做的事情。windows下的接口支持单进程中拥有多个定时器，而linux则只允许单进程拥有一个定时器，因此在linux下的单进程中要使用多个定时器，则需要自己维护管理，这是本文写作的出发点。另外，OS提供的定时器管理算法在大规模定时器的管理方面可能还不尽人意，这时候就需要用户去优化管理算法了，本文在这方面提供了一点素材。

二、一个最简单的多定时器的实现（linux版）
1、实现细节 
  这个实现允许用户使用多个自定义的定时器，每个自定义的定时器将周期地被触发直到其被删除。实现的主要思路是：
    i）首先在初始化多定时器（init_mul_timer）时利用setitimer注册一个基本的时间单位（如1s）的定时事件；
    ii）用户需要set_a_timer注册 自定义定时器 时，在timer_manage管理结构中记录这个定时器的回调函数和定时周期等参数；
    iii）当基本的时间单位到期后（如SIGALRM信号到达时），遍历整个timer_manage，如果有自定义定时器的超时时间到了，就执行相应的回调函数，并将 自定义定时器 的超时时间置为最初值；否则将 自定义定时器 的超时时间相应地减一个基本的时间单位；
    iv）用户通过del_a_timer来删除某个定时器，通 过destroy_mul_timer来删除整个多定时器。
2、代码
i) mul_timer.h

/* This file provides an interface of multiple timers. for convenience, it simplify signal processing.
 * Also, it can't be used in multithreading environment.
 * Author:bripengandre
 * Date:2009-04-29
 */
#ifndef _MUL_TIMER_H_
#define _MUL_TIMER_H_

#include <sys/time.h>

#define MAX_TIMER_CNT 10
#define MUL_TIMER_RESET_SEC 10
#define TIMER_UNIT 60
#define MAX_FUNC_ARG_LEN 100
#define INVALID_TIMER_HANDLE (-1)

typedef int timer_handle_t;

typedef struct _timer_manage
{
    struct _timer_info
    {
        int state; /* on or off */
        int interval;
        int elapse; /* 0~interval */
        int (* timer_proc) (void *arg, int arg_len);
        char func_arg[MAX_FUNC_ARG_LEN];
        int arg_len;
    }timer_info[MAX_TIMER_CNT];

    void (* old_sigfunc)(int);
    void (* new_sigfunc)(int);
    struct itimerval value, ovalue;
}_timer_manage_t;

/* success, return 0; failed, return -1 */
int init_mul_timer(void);
/* success, return 0; failed, return -1 */
int destroy_mul_timer(void);
/* success, return timer handle(>=0); failed, return -1 */
timer_handle_t set_a_timer(int interval, int (* timer_proc) (void *arg, int arg_len),void *arg, int arg_len);
/* success, return 0; failed, return -1 */
int del_a_timer(timer_handle_t handle);

#endif /* _MUL_TIMER_H_ */

ii)mul_timer.c

#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <time.h> 
#include "mul_timer.h"

static struct _timer_manage timer_manage;

static void sig_func(int signo);

/* success, return 0; failed, return -1 */
int init_mul_timer(void)
{
    int ret;
    
    memset(&timer_manage, 0, sizeof(struct _timer_manage));
    if( (timer_manage.old_sigfunc = signal(SIGALRM, sig_func)) == SIG_ERR)
    {
        return (-1);
    }
    timer_manage.new_sigfunc = sig_func;
    
    timer_manage.value.it_value.tv_sec = MUL_TIMER_RESET_SEC;
    timer_manage.value.it_value.tv_usec = 0;
    timer_manage.value.it_interval.tv_sec = TIMER_UNIT;
    timer_manage.value.it_interval.tv_usec = 0;
    ret = setitimer(ITIMER_REAL, &timer_manage.value, &timer_manage.ovalue); 
    
    return (ret);
}


/* success, return 0; failed, return -1 */
int destroy_mul_timer(void)
{
    int ret;
    
    if( (signal(SIGALRM, timer_manage.old_sigfunc)) == SIG_ERR)
    {
        return (-1);


    }

    ret = setitimer(ITIMER_REAL, &timer_manage.ovalue, &timer_manage.value);
    if(ret < 0)
    {
        return (-1);
    } 
    memset(&timer_manage, 0, sizeof(struct _timer_manage));
    
    return(0);
}


/* success, return timer handle(>=0); failed, return -1 */
timer_handle_t set_a_timer(int interval, int (* timer_proc) (void *arg, int arg_len),void *arg, int arg_len)
{
    int i;
    
    if(timer_proc == NULL || interval <= 0)
    {
        return (-1);
    } 
    
    for(i = 0; i < MAX_TIMER_CNT; i++)
    {
        if(timer_manage.timer_info[i].state == 1)
        {
            continue;
        }
        
        memset(&timer_manage.timer_info[i], 0, sizeof(timer_manage.timer_info[i]));
        timer_manage.timer_info[i].timer_proc = timer_proc;
        if(arg != NULL)
        {
            if(arg_len > MAX_FUNC_ARG_LEN)
            {
                return (-1);
            }
            memcpy(timer_manage.timer_info[i].func_arg, arg, arg_len);
            timer_manage.timer_info[i].arg_len = arg_len;
        }
        timer_manage.timer_info[i].interval = interval;
        timer_manage.timer_info[i].elapse = 0;
        timer_manage.timer_info[i].state = 1;
        break;
    }
    
    if(i >= MAX_TIMER_CNT)
    {
        return (-1);
    }
    return (i);
}


/* success, return 0; failed, return -1 */
int del_a_timer(timer_handle_t handle)
{
    if(handle < 0 || handle >= MAX_TIMER_CNT)
    {
        return (-1);
    }
    
    memset(&timer_manage.timer_info[handle], 0,sizeof(timer_manage.timer_info[handle]));
    
    return (0);
}


static void sig_func(int signo)
{
    int i;
    for(i = 0; i < MAX_TIMER_CNT; i++)
    {
        if(timer_manage.timer_info[i].state == 0)
        {
            continue;
        }
        timer_manage.timer_info[i].elapse++;
        if(timer_manage.timer_info[i].elapse == timer_manage.timer_info[i].interval)
        {
            timer_manage.timer_info[i].elapse = 0;
            timer_manage.timer_info[i].timer_proc(timer_manage.timer_info[i].func_arg,timer_manage.timer_info[i].arg_len);
        }
    }
}


#define _MUL_TIMER_MAIN


#ifdef _MUL_TIMER_MAIN

static void get_format_time(char *tstr)
{
    time_t t;
    
    t = time(NULL);
    strcpy(tstr, ctime(&t));
    tstr[strlen(tstr)-1] = '/0';
    
    return;
}


timer_handle_t hdl[3], call_cnt = 0;
int timer_proc1(void *arg, int len)
{
    char tstr[200];
    static int i, ret;
    
    get_format_time(tstr);
    printf("hello %s: timer_proc1 is here./n", tstr);
    if(i >= 5)
    {
        get_format_time(tstr);
        ret = del_a_timer(hdl[0]);
        printf("timer_proc1: %s del_a_timer::ret=%d/n", tstr, ret);
    }
    i++;
    call_cnt++;
    
    
    return (1);
}

int timer_proc2(void * arg, int len)
{
    char tstr[200];
    static int i, ret;
    
    get_format_time(tstr);
    printf("hello %s: timer_proc2 is here./n", tstr);
    if(i >= 5)
    {
        get_format_time(tstr);
        ret = del_a_timer(hdl[2]);
        printf("timer_proc2: %s del_a_timer::ret=%d/n", tstr, ret);
    }
    i++;
    call_cnt++;
    
    return (1);
}


int main(void)
{
    char arg[50];
    char tstr[200];
    int ret;
    
    init_mul_timer();
    hdl[0] = set_a_timer(2, timer_proc1, NULL, 0);
    printf("hdl[0]=%d/n", hdl[0]);
    hdl[1] = set_a_timer(3, timer_proc2, arg, 50);
    printf("hdl[1]=%d/n", hdl[1]);
    hdl[2] = set_a_timer(3, timer_proc2, arg, 101);
    printf("hdl[1]=%d/n", hdl[2]);
    while(1)
    {
        if(call_cnt >= 12)
        {
            get_format_time(tstr);
            ret = destroy_mul_timer();
            printf("main: %s destroy_mul_timer, ret=%d/n", tstr, ret);
            call_cnt++;
        }
        if(call_cnt >= 20)
        {
            break;
        }
    }
    
    return 0;
}

#endif

3、缺陷
   i)新建定时器、遍历定时器和删除定时器（查找哪个定时器超时）时时间复杂度都为O(n)（n是定时器的个数）;
   ii)适用环境是单线程环境，如要用于多线程，需添加同步操作。
   iii)程序中有些小bug，如对新建超时时间为0的定时器没有妥善的处理。

三、多定时器的改进版
1、思路
   改进定时器的实现，即是改善二种所指出的几个缺陷，如下是一个改进版,主要是将遍历超时时间的时间复杂度降为了O(1).
   改善思路:各定时器以一个链表的形式组织起来,除链表头定时器的超时时间是用绝对时间纪录的外,其它定时器的超时时间均用相对时间(即超时时间-前一个定时器的超时时间)纪录.
   注意,各定时器都是一次性的,当定时器的超时被处理后,定时器将被自动删除.另外如果将定时器的结点改为双向结构,可以将删除定时器的时间复杂度降为O(1).
2、数据结构
   每个定时器都有一个唯一的ID,这个ID是如下的结构体:

typedef struct _timer_handle
{
        unsigned long ptr;
        unsigned long entry_id;
}*timer_handle_t;

    ptr纪录的是定时器结点的地址,entry_id则是一个自多定时器初始化后自增的id.ptr和entry_id一起组成定时器结点的key,一方面使得新建定时器时生成key的过程大为简化,另一方面使得删除定时器的时间复杂度降为O(1)（前提是定时器结点采用双向结构）。
   定时器结点的数据结构如下：

/* timer entry */
typedef struct _mul_timer_entry
{
    char is_use; /* 0, not; 1, yes */
    struct _timer_handle handle;
    unsigned int timeout;
    unsigned int elapse; /* */
    int (* timer_proc) (void *arg, unsigned int *arg_len); /* callback function */
    void *arg;
    unsigned int *arg_len;
    struct _mul_timer_entry *etr_next;
}mul_timer_entry_t;

其中的is_use是用来防止这样一种情况：用户在回调函数中调用kill_timer来删除定时器，这个时候kill_timer和遍历定时器中都有删除结点的操作，有可能将整个链表搞混乱。所以在调用用户的回调函数前先将is_use置1，在kill_timer中需检查is_use，只有在 is_use为0的情况下，才执行清理定时器结点的操作。
3、代码（windows版）
i)mul_timer.h

/* This file provides an interface of multiple timers. it can't be used in multithreading environment.
 * Author:bripengandre
 * Date:2009-07-19
 */

#ifndef _MUL_TIMER_H_
#define _MUL_TIMER_H_
#include <windows.h>

typedef struct _timer_handle
{
        unsigned long ptr;
        unsigned long entry_id;
}*timer_handle_t;

/* timer entry */
typedef struct _mul_timer_entry
{
    char is_use; /* 0, not; 1, yes */
    struct _timer_handle handle;
    unsigned int timeout;
    unsigned int elapse; /* */
    int (* timer_proc) (void *arg, unsigned int *arg_len); /* callback function */
    void *arg;
    unsigned int *arg_len;
    struct _mul_timer_entry *etr_next;
}mul_timer_entry_t;

typedef struct _mul_timer_manage
{
    unsigned long entry_id;
    unsigned int timer_cnt;
    unsigned int time_unit;
    struct _mul_timer_entry *etr_head;
    UINT timer_id;
};



struct _mul_timer_manage *init_mul_timer(unsigned int time_unit);
timer_handle_t set_timer(struct _mul_timer_manage *ptimer, unsigned int time_out, int (*timer_proc) (void *arg, unsigned int *arg_len), void *arg, unsigned int *arg_len);
int kill_timer(struct _mul_timer_manage *ptimer, timer_handle_t hdl);
int get_timeout_byhdl(struct _mul_timer_manage *ptimer, timer_handle_t hdl);
int get_timeout_bytimeproc(struct _mul_timer_manage *ptimer, int (* timer_proc) (void*arg, unsigned int *arg_len));
int release_mul_timer(struct _mul_timer_manage *ptimer);

int is_valid_time_hdl(timer_handle_t hdl);

#endif /* _MUL_TIMER_H_ */

ii)mul_timer.c

#include "mul_timer.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>


void CALLBACK traverse_mul_timer(UINT uTimerID, UINT uMsg, DWORD dwUser, DWORD dw1,DWORD dw2);
static int print_mul_timer(struct _mul_timer_manage *ptimer);

struct _mul_timer_manage *init_mul_timer(unsigned int time_unit)
{
    struct _mul_timer_manage *p;
    
    if( (p = malloc(sizeof(struct _mul_timer_manage))) == NULL)
    {
        return (NULL);
    }
    
    p->etr_head = NULL;
    p->timer_cnt = 0;
    p->time_unit = time_unit;
    p->entry_id = 0;
    
    p->timer_id = timeSetEvent(time_unit, 0, (LPTIMECALLBACK )traverse_mul_timer,(DWORD)p, TIME_PERIODIC);
    
    return(p);
}


timer_handle_t set_timer(struct _mul_timer_manage *ptimer, unsigned int time_out, int (*timer_proc) (void *arg, unsigned int *arg_len), void *arg, unsigned int *arg_len)
{
    struct _mul_timer_entry *p, *prev, *pnew;
    
    if(ptimer == NULL || time_out == 0)
    {
        return (NULL);
    }
    
    
    if( (pnew = malloc(sizeof(struct _mul_timer_entry))) == NULL)
    {
        return (NULL);
    }
    pnew->is_use = 0;
    pnew->arg = arg;
    pnew->arg_len = arg_len;
    pnew->elapse = 0;
    pnew->timer_proc = timer_proc;
    
    p = ptimer->etr_head;
    prev = NULL;
    while(p != NULL)
    {
        if(p->timeout < time_out) /* assume the latest time_proc has higher priority */
        {
            time_out = time_out-p->timeout;
            prev = p;
            p = p->etr_next;
        }
        else
        {
            p->timeout -= time_out;
            break;
        }
    }
    
    pnew->timeout = time_out;
    pnew->etr_next = p;
    pnew->handle.ptr = (unsigned long )pnew;
    pnew->handle.entry_id = ptimer->entry_id;
    ptimer->entry_id++;

    if(prev == NULL)
    {
        ptimer->etr_head = pnew;
    }
    else
    {
        prev->etr_next = pnew;
    }    
    ptimer->timer_cnt++;
    
    return (&pnew->handle);
}


int kill_timer(struct _mul_timer_manage *ptimer, timer_handle_t hdl)
{
    struct _mul_timer_entry *p, *prev;
    
    if(ptimer == NULL)
    {
        return (0);
    }
    
    
    p = ptimer->etr_head;
    prev = NULL;
    while(p != NULL)
    {
        if(p->handle.ptr == hdl->ptr && p->handle.entry_id == hdl->entry_id)
        {
            break;
        }

        prev = p;
        p = p->etr_next;
    }
    
    /* no such timer or timer is in use, return 0 */
    if(p == NULL || (p != NULL && p->is_use == 1)) 
    {
        return (0); 
    }
    
    /* has found the timer */
    if(prev == NULL)
    {
        ptimer->etr_head = p->etr_next;
    }
    else
    {
        prev->etr_next = p->etr_next;
    }
    
    /* revise timeout */
    if(p->etr_next != NULL)
    {
        p->etr_next->timeout += p->timeout;
    }
    
    /* delete the timer */
    free(p);
    p = NULL;
    ptimer->timer_cnt--;
    
    return (1);
}


int get_timeout_byhdl(struct _mul_timer_manage *ptimer, timer_handle_t hdl)
{
    struct _mul_timer_entry *p;
    unsigned int timeout;
    
    if(ptimer == NULL || (struct _mul_timer_entry *)(hdl) == NULL)
    {
        return (-1);
    }
    
    
    timeout = 0;
    p = ptimer->etr_head;
    while(p != NULL)
    {
     if(p->handle.ptr == hdl->ptr && p->handle.entry_id == hdl->entry_id)
        {
            break;
        }

        timeout += p->timeout;
        p = p->etr_next;
    }
    
    if(p == NULL)
    {
        return (-1);
    }
    else
    {
        return ((int)timeout+p->timeout);
    }    
    
}


int get_timeout_bytimeproc(struct _mul_timer_manage *ptimer, int (* timer_proc) (void*arg, unsigned int *arg_len))
{
    struct _mul_timer_entry *p;
    unsigned int timeout;
    
    if(ptimer == NULL || timer_proc == NULL)
    {
        return (-1);
    }
    
    p = ptimer->etr_head;
    while((p != NULL) && (p->timer_proc != timer_proc))
    {
        timeout += p->timeout;
        p = p->etr_next;
    }
    
    if(p == NULL)
    {
        return (-1);
    }
    else
    {
        return (timeout+p->timeout);
    }    
}


int release_mul_timer(struct _mul_timer_manage *ptimer)
{
    struct _mul_timer_entry *p, *ptmp;
    
    if(ptimer == NULL)
    {
        return (0);
    }
    
    timeKillEvent(ptimer->timer_id);
    /* delete all timers */
    p = ptimer->etr_head;
    while(p != NULL)
    {
        ptmp = p;
        p = p->etr_next;
        free(ptmp);
    }
    /* delete timer_manage */
    free(ptimer);
    ptimer = NULL;
    
    return (1);
}

int is_valid_time_hdl(timer_handle_t hdl)
{
    if(hdl == NULL)
    {
        return (0);
    }
    else
    {
        return (1);
    }    
}


void CALLBACK traverse_mul_timer(UINT uTimerID, UINT uMsg, DWORD dwUser, DWORD dw1,DWORD dw2)
{
    struct _mul_timer_manage *ptimer;
    struct _mul_timer_entry *p, *ptmp;
    unsigned int timeout;
    
    ptimer = (struct _mul_timer_manage *)dwUser;
    if(ptimer == NULL)
    {
        return;
    }
    
    timeout = ptimer->time_unit;
    p = ptimer->etr_head;
    while(p != NULL)
    {
        if(p->timeout <= timeout)
        {
            p->is_use = 1;
            p->timer_proc(p->arg, p->arg_len);
            ptmp = p;
            timeout -= p->timeout;
            p = p->etr_next;
            free(ptmp);
            ptimer->etr_head = p;
        }
        else
        {
            p->timeout -= timeout;
            p->elapse += timeout;
            ptimer->etr_head = p;
            break;
        }
    }
    if(p == NULL)
    {
        ptimer->etr_head = NULL;
    }    
    
    return; 
}


static int print_mul_timer(struct _mul_timer_manage *ptimer)
{
    struct _mul_timer_entry *p;
    int i;
    
    if(ptimer == NULL)
    {
        return (0);
    }
    
    printf("***************************mul_timer statistics start************************/n");
    printf("this mul_timer's time_unit=%u, etr_head=%p and has %d timers:/n",ptimer->time_unit, ptimer->etr_head, ptimer->timer_cnt);
    
    p = ptimer->etr_head;
    i = 0;
    while(p != NULL)
    {
        printf("the %d timer: timeout=%u, elapse=%u, timer_proc=%p, arg=%p, arg_len=%p, etr_next=%p/n"
            , i+1, p->timeout, p->elapse, p->timer_proc, p->arg, p->arg_len,p->etr_next);
        p = p->etr_next;
        i++;
    }
    printf("***************************mul_timer statistics end************************/n");
    
    return (1);
}


#define _MUL_TIMER_MAIN

#ifdef _MUL_TIMER_MAIN

static void get_format_time(char *tstr)
{
    time_t t;
    
    t = time(NULL);
    strcpy(tstr, ctime(&t));
    tstr[strlen(tstr)-1] = '/0';
    
    return;
}

timer_handle_t hdl[100];
int call_cnt = 0;
struct _mul_timer_manage *ptimer;

int timer_proc1(void *arg, unsigned int *len)
{
    char tstr[200];
    static int i, ret;
    
    get_format_time(tstr);
    printf("call_cnt=%d, hello %s: timer_proc1 is here./n", call_cnt, tstr);
    i++;
    call_cnt++;
    
    
    return (1);
}

int timer_proc2(void * arg, unsigned int *len)
{
    char tstr[200];
    static int i, ret;
    
    get_format_time(tstr);
    printf("call_cnt=%d, hello %s: timer_proc2 is here: arg = %s, len = %d./n",call_cnt, tstr, arg, *len);
    i++;
    call_cnt++;
    
    return (1);
}


int main(void)
{
    char arg[50] = "hello, multiple timers";
    char tstr[200];
    int ret;
    int len = 50, i;
    
    ptimer = init_mul_timer(1000);
    
    for(i = 0; i < 10; i++)
    {
        hdl[i<<1] = set_timer(ptimer, 1000*(i+1), timer_proc1, NULL, NULL);
        printf("hdl[0i<<1=%d, is_valid_hdl=%d/n", hdl[i<<1],is_valid_time_hdl(hdl[i<<1]));
        hdl[(i<<1)+1] = set_timer(ptimer, 3000*(i+1), timer_proc2, arg, &len);
        printf("hdl[i<<1+1]=%d, is_valid_hdl=%d/n", hdl[(i<<1)+1],is_valid_time_hdl(hdl[(i<<1)+1]));
        print_mul_timer(ptimer);
    }

    ret = kill_timer(ptimer, hdl[17]);
    printf("ret=kill_timer=%d/n", ret);
    print_mul_timer(ptimer);    
    printf("hd[19]->timout=%d/n", get_timeout_byhdl(ptimer, hdl[19]));

    while(1)
    {
        if(call_cnt == 15)
        {
            get_format_time(tstr);
            ret = release_mul_timer(ptimer);
            printf("call_cnt=%d, main: %s destroy_mul_timer, ret=%d/n", call_cnt, tstr,ret);
            call_cnt++;
        }
    }
    
    return 0;
}

#endif

3、缺陷
i)新建定时器的时间复杂度为O(n),删除定时器的时间复杂度也为O(n)(简单地将定时器结点改为双向结构,可将复杂度降为O(1));
ii)不能用于多线程环境
四 、多定时器的工业级实现
 1、time wheelz算法
   以前的BSD内核以及现在的linux内核的实现与三中所用算法相似（未实证，只是据说），据说现在的BSD内核已采用了较好的time wheelz算法。
   time wheez算法的优点：
   i)将新建定时器的时间复杂度降近似为O(1)。它根据定时器的超时值，将新定时器散列到hash桶中；
   ii)遍历检查定时器的时间复杂度也近似为O(桶大小)，如果散列均匀。
   iii)删除定时器的时间复杂度近似为O(1)，通过hash算法或临时存储（空间换时间的算法）。
2、time wheelz的实现
   请参考文末给出的两个论文，惭愧得很，文章我也只是稍微瞄了下，以后有用得着的时候再深究吧。
五、参考文章
1、 Adam M. Costello and George Varghess, "Redesigning the BSD Callout and Timer Facilities". 1995.01,这篇文章实现了用time wheelz算法改善BSD内核的定时器算法，google一下，有免费下载；
2、George Varghess, Anthony Lauch, "Hashed and Hierarchical Timing Wheels: Efficient Data Structures for Implementing a Timer Facility". IEEE: 1997.12，这个看作者有没有提供免费下载了，否则是要从IEEE那里获取了~~

erick
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux下实时定时器的实现及应用.PDF
08-24
Linux下实时定时器的实现及应用.PDF
Linux多定时器实现
zdw6868的博客
07-25 1523
一、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 1012
原理利用select()方法的第5个参数，第一个参数设置为0，三个文件描述符集都设置为NULL，第5个参数为时间结构体，这种方法精度能够达到微妙级别，网上有很多基于select()的多线程定时器，说明select()稳定性还是非常好。问题描述：windows下的接口支持单进程中拥有多个定时器，而linux则只允许单进程拥有一个定时器，因此在linux下的单进程中要使用多个定时器，则需要自己维护管理。看APUE神书时候看到的，方法比较冷门，通过使用select()，来设置。
SetTimer的使用问题
seu_xuxueqi的专栏
06-27 3782
定时器的使用：三种方法如果您需要在整个程序执行期间都使用定时器，那么您将得从WinMain函数中或者在处理WM_CREATE消息时呼叫SetTimer，并在退出WinMain或响应WM_DESTROY消息时呼叫KillTimer。根据呼叫SetTimer时使用的参数，可以下列三种方法之一使用定时器。方法一这是最方便的一种方法，它让Windows把WM_TIMER消息发送到应用程序的正常窗口消息处理
linux编程之经典多级时间轮定时器(C语言版)
qq_40989769的博客
02-24 1381
上图是5个时间轮级联的效果图。中间的大轮是工作轮，只有在它上的任务才会被执行；其他轮上的任务时间到后迁移到下一级轮上，他们最终都会迁移到工作轮上而被调度执行。多级时间轮的原理也容易理解：就拿时钟做说明，秒针转动一圈分针转动一格；分针转动一圈时针转动一格；同理时间轮也是如此：当低级轮转动一圈时，高一级轮转动一格，同时会将高一级轮上的任务重新分配到低级轮上。从而实现了多级轮级联的效果。1.1 多级时间轮对象关于轮子上指针的位置有一个比较巧妙的办法：那就是位运算。
linux下自定义定时器的实现
08-29
linux下实现应用层的定时器的创建，开启，支持调用系统消息开启定时器
linux下多定时器+线程池的实现（经典）
01-11
//linux只允许单进程拥有一个定时器，因此在linux下的单进程中要使用多个定时器，则需要自己维护管理 // //这个实现允许用户使用多个自定义的定时器，每个自定义的定时器将周期地被触发直到其被删除。实现的主要思路...
Linux下实现定时器Timer的几种方法总结
09-15
下面小编就为大家带来一篇Linux下实现定时器Timer的几种方法总结。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
linux下的多定时器实现
08-25
文件列表：timer.h，timer.c 功能：实现了linux下的多定时器，采用双向链表来维护定时器列表，用户可利用其中的接口来创建定时器，并注册超时回调函数。时钟计时采用select系统调用来实现。
Linux下一种高效多定时器实现
热门推荐
LouisozZ的专栏
08-29 1万+
Linux下一种高效多定时器实现 作者：LouisozZ 日期：2018.08.29 运行环境说明 由于在 Linux 系统下一个进程只能设置一个时钟定时器，所以当应用需要有多个定时器来共同管理程序运行时，就需要自行实现多定时器管理。 本文就是基于这种需求，在实际编码工作的基础上总结而出，希望跟大家共享，也欢迎大家讨论指正。 多定时器原理 在一个进程只能有一个定时器的前提条件下...
Linux: 定时器实现简析
JiMoKuangXiangQu的专栏
05-11 837
Linux, timer
51单片机c语言多个定时程序,51单片机C语言程序(二)定时计数器中断.doc
weixin_39603799的博客
05-17 450
51单片机C语言程序(二)定时/计数器?中断程序一利用定时/计数器T0从P1.0输出周期为1s 的方波，让发光二极管以1HZ闪烁，#include? //52单片机头文件#include //包含有左右循环移位子函数的库#define uint unsigned int??? //宏定义#define uchar unsigned char? //宏定义sbit P1_0=P1^0;uchar ...
LINUX使用一个定时器实现设置任意数量定时器
weixin_30824599的博客
08-07 121
本例子参考Don Libes的Title: Implementing Software Timers例子改写 为什么需要这个功能，因为大多数计算机软件时钟系统通常只能有一个时钟触发一次中断。当运行多个任务时，我们会想要多个定时器 的时钟跟踪并发这样可以生成正确的时间重叠，操作系统这样做。 本例子是为了实现使用Linux下的一个定时器，实现任一数量的定时器功能。 ...
关于linux下定时器，多定时器
cqltbe131421的博客
04-18 1527
在windows下，我们可以创建多个定时器，而且也可以删除，没个定时器有独立的id号可以区分，但是在linux下一个线程只能有一个定时器，这让我们需要使用多个定时器任务就显得有点尴尬了。但是也不是没有办法。 下面我们来对比windows下的定时器和linux下的定时器任务 MMRESULT timer_handle; 定义一个定时器id； timer_ha
c语言 多线程定时器,C语言实现的多线程定时器
weixin_42131890的博客
05-22 2627
1. 大致功能介绍实现任务列表，定时器会间隔一段时间遍历列表发现要执行的任务任务列表中的所有任务并行执行每个任务都可以有自己的定时器，并且可以选择是否要重复执行定义方便的任务函数实现接口定时器可以由用户自定义何时启动和停止提供等待功能，保证任务列表中的所有任务执行完成提供任务列表的传参功能2. API库介绍void setTick(int val);设置定时间的间隔时间tick，若设置tick为1...
利用一个硬件定时器实现多个虚拟定时器的两种方法
lin111000713的专栏
08-14 4480
第一种方法比较适合单片机，第二种方法在 PC 上很有优势。 1.固定周期法  使用一个硬件定时器进行固定周期(比如 1m s)定时，用一个结构体数组作为软定时器描  述表， 数组的结构体数就是最大虚拟定时器的数量，  每个结构体的成员都包括虚拟定时器状  态(空闲、激活、运行、超时触发、周期触发)、定时值(换算成定时周期数，例如  1m s  的硬  件定时周期， 现进行 125m s
c语言定时器的实现,C语言实现简单的定时器
weixin_39638309的博客
05-19 5755
本文实例为大家分享了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...
程序运行时间的控制
学如逆水行舟，不进则退！
03-11 1494
今天看书上，搞懂了很长时间没有解决的问题；代码如下： #include #include   int _tmain(int argc, _TCHAR* argv[]) { using namespace std; int time; cin>>time; clock_t delay=time*CLOCKS_PER_SEC;//这里的常量是每
Linux下实现定时器
最新发布
05-18
在Linux中，有几种方法可以实现定时器功能： 1. 使用系统调用 alarm()：该调用会在指定的时间（以秒为单位）后触发SIGALRM信号。可以通过注册信号处理函数来处理该信号，实现定时器功能。例如： ``` #include #...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值