一个简易的事件队列的实现

第一章：实现队列

我觉得实现一个队列还是比较有意思的事情，采用常见的循环数组实现的方式。

值得注意的是，Item项是void *类型的，也就是说这个队列可以存储任意类型，因为我们其实存储的是指针。（这么描述真的没问题吗？）

queue.h的源代码如下

/**

 * @file    queue.h

 * @brief

 * */

#ifndef QUEUE_H

#define QUEUE_H
#define MAXQUEUESIZE 1000

typedef enum boolean{False,True} bool;

typedef void * Item;

typedef struct Queue * QueueADT;

QueueADT NewQueue(void);

void FreeQueue(QueueADT queue);

void EnQueue(QueueADT queue,Item x);

Item DeQueue(QueueADT queue);

bool QueueIsEmpty(QueueADT queue);

bool QueueIsFull(QueueADT queue);

int QueueLength(QueueADT queue);

Item GetQueueItem(QueueADT queue,int index);

#endif

queue.c的源代码如下：

/**

 * @file    queue.c

 * @brief

 */

#include <stdio.h>

#include <stdlib.h>

#include <malloc.h>

#include <assert.h>

#include "queue.h"

struct Queue

{

    Item elements[MAXQUEUESIZE];

    int iHead;

    int iCount;

};

QueueADT NewQueue(void)

{

    QueueADT queue;

    queue = (QueueADT)malloc(sizeof(struct Queue));

    queue->iHead = queue->iCount = 0;

    return (queue);

}

void FreeQueue(QueueADT queue)

{

    free(queue);

}

void EnQueue(QueueADT queue,Item x)

{

    if(QueueIsFull(queue))

    {

        printf("QueueIsFull\n");

        exit(-1);

    }

    queue->elements[(queue->iHead+queue->iCount)%MAXQUEUESIZE] = x;

    queue->iCount++;

}

Item DeQueue(QueueADT queue)

{

    Item result;

    if(QueueIsEmpty(queue))

    {

        printf("QueueIsEmpty\n");

        exit(-1);

    }

    result = queue->elements[queue->iHead];

    queue->iHead = (queue->iHead + 1)%MAXQUEUESIZE;

    queue->iCount--;

    return (result);

}

bool QueueIsEmpty(QueueADT queue)

{

    return (queue->iCount == 0);

}

bool QueueIsFull(QueueADT queue)

{

    return (queue->iCount == MAXQUEUESIZE);

}

int QueueLength(QueueADT queue)

{

     return (queue->iCount);

}

Item GetQueueItem(QueueADT queue,int index)

{

    if(index >= 0 && index < QueueLength(queue))

    {

        return queue->elements[(queue->iHead + index)%MAXQUEUESIZE];

    }

    printf("index < 0 or index > queue length\n");

    exit(-1);

}

第二章：事件队列

事件队列实在队列API上做一个简单的封装。

只是添加了一个DoEvent(QueueADT queue)函数。

Event.h

#ifndef MY_EVENT_H

#define MY_EVENT_H

#include "queue.h"

#define NewEventQueue() NewQueue()

typedef struct Event * Event_ptr;

void FreeEventQueue(QueueADT queue,void(*FreeEventNode)(Event_ptr x));

void EnEventQueue(QueueADT queue,void (* pEvent)(void * argument),void * argument, size_t size);

void DoEvent(QueueADT queue);

#endif // MY_EVENT_H

 

Event.c

#include <assert.h>

#include <stdlib.h>

#include <stdio.h>

#include "Event.h"

#include <string.h>

typedef struct Event

{

    void (* pEvent)(void * argument);

    void * argument;

}Event;

inline static void QuitIfPtrIsNULL(void * ptr,const char * message)

{

    if(ptr == NULL)

    {

        fprintf(stderr,"%s\n",message);

        exit(-1);

    }

}

void FreeEventQueue(QueueADT queue,void(*FreeEventNode)(Event_ptr x))

{

    int i = 0;

    for(i = 0;i < QueueLength(queue);i++)

    {

        FreeEventNode(GetQueueItem(queue,i)); //释放单个节点malloc的内存，由用户实现

    }

    FreeQueue(queue);

}

void EnEventQueue(QueueADT queue,void (* pEvent)(void * argument),void * argument, size_t size)

{

    Event * x = NULL;

    QuitIfPtrIsNULL(queue,"queue == NULL");

    QuitIfPtrIsNULL(pEvent,"pEvent == NULL");

    x = (Event *)malloc(sizeof(Event));

    QuitIfPtrIsNULL(x,"malloc error");

    x->pEvent   = pEvent;

    x->argument = malloc(size);

    memcpy(x->argument,argument,size);

    EnQueue(queue,x);

}

void DoEvent(QueueADT queue)

{

    Event * x = NULL;

    QuitIfPtrIsNULL(queue,"queue == NULL");

    if(!QueueIsEmpty(queue))

    {

        x = DeQueue(queue);

        QuitIfPtrIsNULL(x,"some thing is wrong");

        x->pEvent(x->argument);

        free(x->argument);

        free(x);

    }

}

 

第三章：事件模拟

在完成底层库之后，可以进行事件模拟了，当然，由于在linux下面编程，略微风骚的扩展了下功能，用了定时器，一次检测事件，一次处理事件。

代码如下：

#include <stdio.h>

#include <stdlib.h>

#include <sys/select.h>

#include <sys/time.h>

#include <unistd.h>

#include <signal.h>

#include <termios.h>

#include "queue.h"

#include "Event.h"

#include "kbhit.h"

unsigned int TimerCount;

QueueADT queue;

void PrintChar(void * c)

{

    char * a = (char *)c;

    printf("\n%c",*a);

}

void timefunc(int sig)      /* 定时事件代码 */

{

    if(TimerCount++ % 7 != 0)　　　　　　　　　　　　　　　　//why I am 7,but not 2?

    {

        if(kbhit())

        {

            char c = getch();

            EnEventQueue(queue,PrintChar,&c,sizeof(c));

        }

    }

    else

    {

        DoEvent(queue);

    }

    signal(SIGPROF, timefunc);    /* 捕获定时信号 */

}

int main()

{

    queue = NewQueue();

    struct itimerval value;

    value.it_value.tv_sec       = 0;    // 定时1.5秒

    value.it_value.tv_usec      = 100000;

    value.it_interval.tv_sec    = 0;    // 定时1.5秒

    value.it_interval.tv_usec   = 100000;

    signal(SIGPROF, timefunc);     // 捕获定时信号

    setitimer(ITIMER_PROF, &value, NULL); // 定时开始

    while (1);

    return 0;

}

 

如上所示，假如TimerCount++ % 2 == 0 那么检测事件的频率和处理事件的频率就一样了，通过调整参数，我们可看到经典讨论下reader和writter问题。

让读者的频率加快，或者让写者的速率加快。

由于linux下面没有kbhit和getch函数，所以照搬了网上的两段代码，如下。

#include <stdio.h>

#include <termios.h>

#include <unistd.h>

#include <fcntl.h>

int kbhit(void)

{

    struct termios oldt, newt;

    int ch;

    int oldf;

    tcgetattr(STDIN_FILENO, &oldt);

    newt = oldt;

    newt.c_lflag &= ~(ICANON | ECHO);

    tcsetattr(STDIN_FILENO, TCSANOW, &newt);

    oldf = fcntl(STDIN_FILENO, F_GETFL, 0);

    fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);

    ch = getchar();

    tcsetattr(STDIN_FILENO, TCSANOW, &oldt);

    fcntl(STDIN_FILENO, F_SETFL, oldf);

    if(ch != EOF)

    {

        ungetc(ch, stdin);

        return 1;

    }

    return 0;

}



int getch(void)

{

    struct termios oldt,newt;

    int ch;

    tcgetattr( STDIN_FILENO, &oldt );

    newt = oldt;

    newt.c_lflag &= ~( ICANON | ECHO );

    tcsetattr( STDIN_FILENO, TCSANOW, &newt );

    ch = getchar();

    tcsetattr( STDIN_FILENO, TCSANOW, &oldt );

    return ch;

}
检验发现，实现的也不是特别好。