liunx高性能服务编程----定时器

网络程序需要处理的第三类事件

网络程序需要处理的第三类事件 ，定时事件。对服务器的性能影响很大，我们需要将每个定时事件封装成定时器，再使用某种容器的数据结构，来串联这些定时器以统一管理。
定时是指在一段时间之后触发某段代码的机制，可以在这段代码内处理所有到期的定时器。
三种liunx提供的定时方法:

• socket选项中的SO_RCVTIMEO 和SO_SNDTIMEO
• SIGALRM 信号
• I /O复用系统调用的超时参数

socket选项中的SO_RCVTIMEO 和SO_SNDTIMEO

只对socket api有效 具体如下

我们可以通过系统调用的返回值 以及errno来判断超时事件是否已经到，进而决定是否开始处理定时任务。下面程序说明 如何使用SO_SNDTIMEO选项来定时。

// 利用SO_SNDTIMEO选项来定时 来定时操作
// 如果在指定事件内没有连接上服务器 则会打印connecting timeout

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <assert.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int timeout_connect( const char* ip, int port, int time )
{
    int ret = 0;
    struct sockaddr_in address;
    bzero( &address, sizeof( address ) );
    address.sin_family = AF_INET;
    inet_pton( AF_INET, ip, &address.sin_addr );
    address.sin_port = htons( port );

    int sockfd = socket( PF_INET, SOCK_STREAM, 0 );
    assert( sockfd >= 0 );

    struct timeval timeout;
    timeout.tv_sec = time;
    timeout.tv_usec = 0;
    socklen_t len = sizeof( timeout );
    ret = setsockopt( sockfd, SOL_SOCKET, SO_SNDTIMEO, &timeout, len );
    assert( ret != -1 );

    ret = connect( sockfd, ( struct sockaddr* )&address, sizeof( address ) );
    if ( ret == -1 )
    {
        if( errno == EINPROGRESS )
        {
            printf( "connecting timeout\n" );
            return -1;
        }
        printf( "error occur when connecting to server\n" );
        return -1;
    }

    return sockfd;
}

int main( int argc, char* argv[] )
{
    if( argc <= 2 )
    {
        printf( "usage: %s ip_address port_number\n", basename( argv[0] ) );
        return 1;
    }
    const char* ip = argv[1];
    int port = atoi( argv[2] );

    int sockfd = timeout_connect( ip, port, 10 );
    if ( sockfd < 0 )
    {
        return 1;
    }
    return 0;
}

SIGALRM信号

如果要处理多个定时任务，就要不断触发SIGALRM信号 并且在信号处理函数中执行到期的任务。
一般是由alarm 和 setitimer函数来设置定时任务 不断触发SIGALRM信号。

下面通过实例–处理非活动连接，来介绍如何使用SIGALRM信号定时。一种简单的定时器实现，基于升序链表的定时器实现。通过这个案例来观察 SIGALRM信号处理函数是如何处理定时器并执行定时任务的。
后面将会拿这种定时器和高效定时器-时间轮和时间堆作对比。

基于升序链表的定时器

定时器至少包含成员：超时时间 和 超时回调函数
可选参数 是否重启定时器，如果是链表还要考虑是否有前后定时器的指针成员

下面实现了一个简单的升序定时器链表。升序定时器链表将其中的定时器按照超时事件做升序排序zz

#ifndef LST_TIMER
#define LST_TIMER

#include <time.h>

#define BUFFER_SIZE 64
class util_timer;
struct client_data
{
    sockaddr_in address;
    int sockfd;
    char buf[ BUFFER_SIZE ];
    util_timer* timer;
};

class util_timer
{
public:
    util_timer() : prev( NULL ), next( NULL ){}

public:
   time_t expire; 
   void (*cb_func)( client_data* );
   client_data* user_data;
   util_timer* prev;
   util_timer* next;
};

class sort_timer_lst
{
public:
    sort_timer_lst() : head( NULL ), tail( NULL ) {}
    ~sort_timer_lst()
    {
        util_timer* tmp = head;
        while( tmp )
        {
            head = tmp->next;
            delete tmp;
            tmp = head;
        }
    }
    void add_timer( util_timer* timer )
    {
        if( !timer )
        {
            return;
        }
        if( !head )
        {
            head = tail = timer;
            return; 
        }
        if( timer->expire < head->expire )
        {
            timer->next = head;
            head->prev = timer;
            head = timer;
            return;
        }
        add_timer( timer, head );
    }
    void adjust_timer( util_timer* timer )
    {
        if( !timer )
        {
            return;
        }
        util_timer* tmp = timer->next;
        if( !tmp || ( timer->expire < tmp->expire ) )
        {
            return;
        }
        if( timer == head )
        {
            head = head->next;
            head->prev = NULL;
            timer->next = NULL;
            add_timer( timer, head );
        }
        else
        {
            timer->prev->next = timer->next;
            timer->next->prev = timer->prev;
            add_timer( timer, timer->next );
        }
    }
    void del_timer( util_timer* timer )
    {
        if( !timer )
        {
            return;
        }
        if( ( timer == head ) && ( timer == tail ) )
        {
            delete timer;
            head = NULL;
            tail = NULL;
            return;
        }
        if( timer == head )
        {
            head = head->next;
            head->prev = NULL;
            delete timer;
            return;
        }
        if( timer == tail )
        {
            tail = tail->prev;
            tail->next = NULL;
            delete timer;
            return;
        }
        timer->prev->next = timer->next;
        timer->next->prev = timer->prev;
        delete timer;
    }
    void tick()
    {
        if( !head )
        {
            return;
        }
        printf( "timer tick\n" );
        time_t cur = time( NULL );
        util_timer* tmp = head;
        while( tmp )
        {
            if( cur < tmp->expire )
            {
                break;
            }
            tmp->cb_func( tmp->user_data );
            head = tmp->next;
            if( head )
            {
                head->prev = NULL;
            }
            delete tmp;
            tmp = head;
        }
    }

private:
    void add_timer( util_timer* timer, util_timer* lst_head )
    {
        util_timer* prev = lst_head;
        util_timer* tmp = prev->next;
        while( tmp )
        {
            if( timer->expire < tmp->expire )
            {
                prev->next = timer;
                timer->next = tmp;
                tmp->prev = timer;
                timer->prev = prev;
                break;
            }
            prev = tmp;
            tmp = tmp->next;
        }
        if( !tmp )
        {
            prev->next = timer;
            timer->prev = prev;
            timer->next = NULL;
            tail = timer;
        }
        
    }

private:
    util_timer* head;
    util_timer* tail;
};

#endif

I/O复用系统调用的超时参数

liunx的三组I/O复用系统调用都占用超时参数 。所以他们不但能统一处理信号，和I/O事件，也能能处理定时事件。但是I/O复用系统可能在超时事件到期前就返回。所以需要利用他们来定时。就需要不断更新定时参数 以反映剩余的事件。

#define TIMEOUT 5000

int timeout = TIMEOUT;
time_t start = time( NULL );
time_t end = time( NULL );
while( 1 )
{
    printf( "the timeout is now %d mill-seconds\n", timeout );
    start = time( NULL );
    int number = epoll_wait( epollfd, events, MAX_EVENT_NUMBER, timeout );
    if( ( number < 0 ) && ( errno != EINTR ) )
    {
        printf( "epoll failure\n" );
        break;
    }
    /*如果epoll_wait 说明超时事件到 可以在此处理超时任务 并重置超时时间*/
    if( number == 0 )
    {
        // timeout
        timeout = TIMEOUT;
        continue;
    }

    end = time( NULL );
    /*如果大于0 说明epoll wait的持续事件为(end - start) *1000ms
    将定时时间减去这段时间 可以获取下次调用的超时参数*/
    timeout -= ( end - start ) * 1000;
    if( timeout <= 0 )
    {
        // timeout
        timeout = TIMEOUT;
    }

    // handle connections
}

高性能 定时器

时间轮

由于排序链表的定时器存在一个问题： 添加定时器的效率偏低 。
所以一种名为 时间轮的数据结构诞生

匀速顺时间转动 每次转动称为一个滴答(tick) 一个滴答的事件被称为事件轮的间隔槽 实际上就是心博时间。该时间轮有N个槽
因此转动一周的事件是N*si 每次槽指向一条定时器链表，每条链表上面的定时器具有相同的特征。他们的定时事件相差N *si的整数倍。时间轮就是利用这个关系将定时器散布在不同的链表中
假如现在指针指向槽cs，我们要添加一个定时事件为ti的定期器。则将该定时器插入槽ts对应的链表中：
ts = (cs +(ti/si))
相比较于排序链表 插入的操作效率基本不受定时器的影响。

• 要想提高定时精度 就要使si值足够小
• 要提高执行效率 则要求N的值足够大

复杂的时间轮可能有多个轮子 每个轮子都有不同的力度。相邻的轮子。精度高的转一圈 精度第的仅往前移动一槽。就像水表一样。 下面是一个简单的时间轮实现代码

#ifndef TIME_WHEEL_TIMER
#define TIME_WHEEL_TIMER

#include <time.h>
#include <netinet/in.h>
#include <stdio.h>

#define BUFFER_SIZE 64
class tw_timer;
struct client_data
{
    sockaddr_in address;
    int sockfd;
    char buf[ BUFFER_SIZE ];
    tw_timer* timer;
};

class tw_timer
{
public:
    tw_timer( int rot, int ts ) 
    : next( NULL ), prev( NULL ), rotation( rot ), time_slot( ts ){}

public:
    int rotation;
    int time_slot;
    void (*cb_func)( client_data* );
    client_data* user_data;
    tw_timer* next;
    tw_timer* prev;
};

class time_wheel
{
public:
    time_wheel() : cur_slot( 0 )
    {
        for( int i = 0; i < N; ++i )
        {
            slots[i] = NULL;
        }
    }
    ~time_wheel()
    {
        for( int i = 0; i < N; ++i )
        {
            tw_timer* tmp = slots[i];
            while( tmp )
            {
                slots[i] = tmp->next;
                delete tmp;
                tmp = slots[i];
            }
        }
    }
    tw_timer* add_timer( int timeout )
    {
        if( timeout < 0 )
        {
            return NULL;
        }
        int ticks = 0;
        if( timeout < TI )
        {
            ticks = 1;
        }
        else
        {
            ticks = timeout / TI;
        }
        int rotation = ticks / N;
        int ts = ( cur_slot + ( ticks % N ) ) % N;
        tw_timer* timer = new tw_timer( rotation, ts );
        if( !slots[ts] )
        {
            printf( "add timer, rotation is %d, ts is %d, cur_slot is %d\n", rotation, ts, cur_slot );
            slots[ts] = timer;
        }
        else
        {
            timer->next = slots[ts];
            slots[ts]->prev = timer;
            slots[ts] = timer;
        }
        return timer;
    }
    void del_timer( tw_timer* timer )
    {
        if( !timer )
        {
            return;
        }
        int ts = timer->time_slot;
        if( timer == slots[ts] )
        {
            slots[ts] = slots[ts]->next;
            if( slots[ts] )
            {
                slots[ts]->prev = NULL;
            }
            delete timer;
        }
        else
        {
            timer->prev->next = timer->next;
            if( timer->next )
            {
                timer->next->prev = timer->prev;
            }
            delete timer;
        }
    }
    void tick()
    {
        tw_timer* tmp = slots[cur_slot];
        printf( "current slot is %d\n", cur_slot );
        while( tmp )
        {
            printf( "tick the timer once\n" );
            if( tmp->rotation > 0 )
            {
                tmp->rotation--;
                tmp = tmp->next;
            }
            else
            {
                tmp->cb_func( tmp->user_data );
                if( tmp == slots[cur_slot] )
                {
                    printf( "delete header in cur_slot\n" );
                    slots[cur_slot] = tmp->next;
                    delete tmp;
                    if( slots[cur_slot] )
                    {
                        slots[cur_slot]->prev = NULL;
                    }
                    tmp = slots[cur_slot];
                }
                else
                {
                    tmp->prev->next = tmp->next;
                    if( tmp->next )
                    {
                        tmp->next->prev = tmp->prev;
                    }
                    tw_timer* tmp2 = tmp->next;
                    delete tmp;
                    tmp = tmp2;
                }
            }
        }
        cur_slot = ++cur_slot % N;
    }

private:
    static const int N = 60;
    static const int TI = 1; 
    tw_timer* slots[N];
    int cur_slot;
};

#endif

对于一个时间轮来说 添加定时器的时间复杂度是O(1) 删除一个定时器的时间复杂度也是O(1) 执行一个定时器的事件复杂度是O(n) 实际上执行一个定时器的效率比0(N)要好。因为时间轮将所有的定时器都散列到了不同的链表上。 时间轮的槽越多。等价于散列表的入口就越多。当我们使用多个轮子来执行的时候 时间复杂度 将越接近O(1)