用户名: 密码: 忘记密码? 注册

单进程中利用alarm实现动态定时器

作者:  时间: 2010-11-20
    要求如题所示,在单个进程中实现动态定时器。因为每个进程只能有一个闹钟时钟,所以在调用alarm时,若以前已经为该进程设置时钟,而且它还没有超时,则将该闹钟的余值作为本次alarm的返回值。以前登记的闹钟时钟被新值取代。
   对于这个题目,我的设计是:定义一个限量的结构体数组(TASK如下所示),用于承载不同的计时任务,根据任务的状态决定alarm到时后的操作,从而实现动态定时。
   在任务结构体中
   taskid表示任务ID,在实际操作中使其等于所在位置的数组号;
   xsec表示相对时间,为了便于操作,任务数组里的时间被规划为同一起点的时间。每当有任务到时、新任务加入或有任务被删除时,数组时间被更新;
   job表示所要执行的任务;
   flag是状态标识,RUNNING为运行态,即处于该状态的任务在计时到时后被执行;WAITTING为等待,因为此状态的相对时间大于RUNNING态的任务,所以在alarm到时前不需作操作,alarm到时后,相对时间更新(所有WAITTING态的任务相对时间减去RUNNING态相对时间),RUNNING态任务变为COMPLETED态,然后把WAITTING态中最小时间的任务设为新的RUNNING态。

typedef struct mytask {
    int taskid; //任务ID
    int xsec; //相对时间
    jobFunc job;//到期执行任务
    int flag;   
}TASK;
代码如下,由于时间仓促,只完成基本功能,以后再作优化。
头文件timer.h

#ifndef __TIMER__H
#define __TIMER__H

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <strings.h>
#include <string.h>


#define TASK_MAX 100
#define TASK_BUF_SIZE 1024

typedef void(*jobFunc)(void);

enum {
    COMPLETED,
    WAITTING,
    RUNNING,
        
};

typedef struct mytask {
    int taskid;
    int xsec; //相对时间

    jobFunc job;//到期执行任务

    int flag;    
}TASK;

void new_run(void);
int add_job();
int del_job();
void regeneration_time(int base);
int find_and_store(jobFunc job, int expire);
int search(int taskid,int flag);
void do_job(int s);
void print(void);
void print_menu(void);

#endif


mytimer.c

#include "timer.h"


TASK task[TASK_MAX];    //任务数组

int taskcnt = 0;        //当前任务数量



void job_1(void)
{
    printf("***job_1 over***\n");
}

void new_run(void)
{
    int ret,min,i;
    ret = search(-1,WAITTING);
    min = ret;
    if(taskcnt >= 1)
    {
        for(i=0;i<TASK_MAX;i++)
            if(WAITTING == task[i].flag)
                if(task[min].xsec > task[i].xsec)
                    min = i;    
        task[min].flag = RUNNING;
        alarm(task[min].xsec);
    }    
    //还缺少相等情况    

}

void do_job(int s)
{
    int i,ret,min;
    for(i=0;i<TASK_MAX;i++)
    {
        if(RUNNING == task[i].flag)
        {
            task[i].job();
            task[i].flag = COMPLETED;
            ret = i;
        }
    }
    taskcnt--;
    regeneration_time(task[ret].xsec);    //更新

    new_run();
}



int search(int taskid,int flag)
{
    int i;
    
    if(flag >= 0)
    {
        for(i=0;i<TASK_MAX;i++)
            if(task[i].flag == flag)
                return i;        
    }
    if(taskid >= 0)
    {
        for(i=0;i<TASK_MAX;i++)
            if(task[i].taskid == taskid)
                return i;        
    }
}

void regeneration_time(int base)
{
    int i;
    for(i=0;i<TASK_MAX;i++)
    {
        if(task[i].flag == WAITTING)
            task[i].xsec = task[i].xsec - base;
    }
}

int find_and_store(jobFunc job, int expire)
{
    int ret,ret2;

    ret = search(-1,COMPLETED);
    
    task[ret].taskid = ret;
    task[ret].xsec = expire;
    task[ret].job = job;
    task[ret].flag = WAITTING;
    
    ret2 = search(-1,RUNNING);
    if(expire < task[ret2].xsec)
    {
        //缺少对同为running状态的改变

        task[ret2].flag = WAITTING;
        task[ret].flag = RUNNING;
        alarm(expire);    
    }
    else if(expire == task[ret2].xsec)
    {
        task[ret].flag = RUNNING;
        alarm(expire);
    }
    else
        alarm(task[ret2].xsec);
    return 0;    
}

int add_job(void)
{
    int ret,lsec,base,jobnum;
    int taskid,expire;
    jobFunc job=job_1;
    
    
    printf("in put time:\n");
    scanf("%d",&expire);
    getchar();
    
    if(taskcnt==0)
    {
        task[0].taskid = 0;
        task[0].xsec = expire;
        task[0].job = job;
        task[0].flag = RUNNING;
        alarm(expire);    
    }
    else
    {
        ret = search(-1,RUNNING);    //排在第一位任务的位置

        lsec = alarm(0);    //剩余alarm时间

        base = task[ret].xsec - lsec;    //已过的时间

        task[ret].xsec = lsec;
        regeneration_time(base);
        find_and_store(job,expire);
    }
    taskcnt++;
    return 0;        
}

void print(void)
{
    int i;
    for(i=0;i<TASK_MAX;i++)
        if((task[i].flag == WAITTING)||(task[i].flag == RUNNING))
            printf("taskid:%d\n",task[i].taskid);
}

int del_job(void)
{
    int id,lsec,base,ret;
    char inc[10];
    printf("input the taskid:\n");
    fgets(inc,10,stdin);
    ret = strlen(inc);
    inc[ret-1] = '\0';
    id = atoi(inc);
    if(task[id].flag == RUNNING)
    {    
        task[id].flag = COMPLETED;
        lsec = alarm(0);
        base = task[id].xsec - lsec;
        regeneration_time(base);
        new_run();
    }
    else
        task[id].flag = COMPLETED;
    taskcnt--;
    return 0;
}

void print_menu(void)
{
    printf("1.add\t2.del\t3.show\n");
}

int main(void)
{
    char inc[10];
    
    signal(SIGALRM, do_job);
    bzero(task,sizeof(TASK)*TASK_MAX);
    
    while(1)
    {
        print_menu();
        fgets(inc,10,stdin);
        
        switch(inc[0])
        {
            case '1':add_job();break;
            case '2':del_job();break;
            case '3':print();break;
            default :break;
        }    
    }    
    return 0;
}


文件:timer.tar.gz
大小:4KB
下载:下载