最小堆定时器

基于最小堆实现的网络定时器

头文件

//
// Created by wenfan on 2021/3/21.
//

#ifndef MIN_HEAP_H
#define MIN_HEAP_H

#include <iostream>
#include <netinet/in.h>
#include <ctime>

using std::exception;

#define BUFFER_SIZE 64

class heap_timer;  //前向声明

struct client_data{
    sockaddr_in address;
    int sockfd;
    char buf[BUFFER_SIZE];
    heap_timer* timer;
};

class heap_timer{
public:
    heap_timer(int delay){
        expire = time(NULL) + delay;
    }
public:
    time_t expire;  //定时器生效的绝对时间
    void (*cb_func)(client_data*); // 定时器的回调函数
    client_data* user_data; //用户数据
};


class time_heap{
public:
    time_heap(int) throw(std::exception);
    time_heap(heap_timer** init_array, int size, int capacity) throw(std::exception);
    ~time_heap();

public:
    void add_timer(heap_timer* timer) throw(std::exception);
    void del_timer(heap_timer* timer);
    void pop_timer();
    void tick();
    heap_timer* top() const{
        if(empty())
            return NULL;
        return array[0];
    }
    bool empty() const{
        return cur_size == 0;
    }

private:
    //最小堆的下虑操作，确保堆数组中以第hole个节点作为根的子树拥有最小堆性质
    void percolate_down(int hole){
        heap_timer* tmp = array[hole];
        int child = 0;
        for(; ((hole*2 + 1) <= (cur_size-1));hole = child){
            child = hole*2 + 1;
            if((child < cur_size-1) && (array[child+1]->expire < array[child]->expire)){
                child++;
            }
            if(array[child]->expire < tmp->expire){  // 孩子的权值还比插入的小，只能往下走了。
                array[hole] = array[child];
            }else
                break;
        }
        array[hole] = tmp;
    }
    void resize() throw(std::exception){

        heap_timer** tmp = new heap_timer* [capacity*2];
        for (int j = 0; j < capacity*2; ++j) {
            tmp[j] = NULL;
        }
        if(!tmp){
            throw std::exception();
        }
        for(int i = 0;i < cur_size;i++){
            tmp[i] = array[i];
            delete array[i];
        }
        delete []array;
        capacity = capacity*2;
    }
private:
    heap_timer** array; //堆数组
    int capacity; //堆数组的容量
    int cur_size; //堆数组包含元素的个数
};

#endif //MIN_HEAP_H

实现函数

//
// Created by wenfan on 2021/3/21.
//

#include "min_heap.h"

time_heap::time_heap(int cap) throw(std::exception) : capacity(cap), cur_size(0){
    array = new heap_timer* [capacity];  //创建堆数组
    if(!array)
        throw std::exception();
    for (int i = 0; i < capacity; ++i) {
        array[i] = NULL;
    }
}

time_heap::time_heap(heap_timer** init_array, int size, int capacity) throw(std::exception): cur_size(size), capacity(capacity){
    if(capacity < size){
        throw std::exception();
    }
    array = new heap_timer*[capacity];
    if(array)
        throw std::exception();
    for (int i = 0; i < capacity; ++i) {
        array[i] = NULL;
    }
    if(size > 0){
        for (int i = 0; i < size; ++i) {
            array[i] = init_array[i];
            percolate_down(i);
        }
    }
}

time_heap::~time_heap(){
    for (int i = 0; i < cur_size; ++i) {
        delete array[i];
    }
    delete []array;
}

void time_heap::add_timer(heap_timer* timer) throw(std::exception){
    if(!timer)
        return;
    if(cur_size > capacity)
        resize();
    int hole = cur_size++;
    int parent = 0;
    for(;hole > 0;hole = parent){
        parent = (hole - 1)/2;
        if(array[parent]->expire <= timer->expire){
            break;
        }
        array[parent] = array[hole];
    }
    array[hole] = timer;
}

void time_heap::del_timer(heap_timer* timer){
    if(!timer)
        return;
    /**
     * 仅仅将回调函数设置为空，即延迟销毁，这样节省了，定时器造成的开销，但这样做使得堆数组容易膨胀。
     */
    timer->cb_func = NULL;
}

void time_heap::pop_timer(){
    if(empty())
        return;
    if(array[0]){
        delete array[0];
        array[0] = array[--cur_size];
        percolate_down(0);// 对新的堆顶元素执行下虑操作
    }
}

/**
 * 心搏函数
 */
void time_heap::tick(){
    heap_timer* tmp = array[0];
    time_t cur = time(NULL);
    while(!empty()){
        if(!tmp)
            break;
        if(tmp->expire > cur){
            break;
        }
        if(array[0]->cb_func){
            array[0]->cb_func(array[0]->user_data);
        }
        pop_timer();
        tmp = array[0];
    }
}