1
/**
2
 * 获取事件数量
3
 * @param base  event_base
4
 * @param type  事件类型（EVENT_BASE_COUNT_*的组合）
5
 * @return 事件数量
6
 */
7
int event_base_get_num_events(struct event_base *base, unsigned int type);
8

9
/**
10
 * 获取最大事件数量
11
 * @param base  event_base
12
 * @param type  事件类型
13
 * @param clear 是否清除最大值
14
 * @return 最大事件数量
15
 */
16
int event_base_get_max_events(struct event_base *base, unsigned int type, int clear);

1
int event_add_nolock_(struct event *ev, const struct timeval *tv, int tv_is_absolute) {
2
    struct event_base *base = ev->ev_base;
3

4
    // 增加事件计数
5
    base->event_count++;
6
    if (base->event_count > base->event_count_max)
7
        base->event_count_max = base->event_count;
8

9
    // 如果是定时器，增加虚拟事件计数
10
    if (tv != NULL) {
11
        base->virtual_event_count++;
12
        if (base->virtual_event_count > base->virtual_event_count_max)
13
            base->virtual_event_count_max = base->virtual_event_count;
14
    }
15

16
    // ...
17
}

1
int event_del_nolock_(struct event *ev, int blocking) {
2
    struct event_base *base = ev->ev_base;
3

4
    // 减少事件计数
5
    base->event_count--;
6

7
    // 如果是定时器，减少虚拟事件计数
8
    if (ev->ev_flags & EVLIST_TIMEOUT) {
9
        base->virtual_event_count--;
10
    }
11

12
    // 如果在活跃队列中，减少活跃事件计数
13
    if (ev->ev_flags & EVLIST_ACTIVE) {
14
        base->event_count_active--;
15
    }
16

17
    // ...
18
}

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <unistd.h>
4
#include <event2/event.h>
5

6
static void print_event_stats(struct event_base *base) {
7
    int active = event_base_get_num_events(base, EVENT_BASE_COUNT_ACTIVE);
8
    int virtual = event_base_get_num_events(base, EVENT_BASE_COUNT_VIRTUAL);
9
    int added = event_base_get_num_events(base, EVENT_BASE_COUNT_ADDED);
10

11
    printf("Event Statistics:\n");
12
    printf("  Active events: %d\n", active);
13
    printf("  Virtual events: %d\n", virtual);
14
    printf("  Total added events: %d\n", added);
15
}
16

17
static void timer_cb(evutil_socket_t fd, short events, void *arg) {
18
    struct event_base *base = arg;
19
    static int count = 0;
20

21
    count++;
22
    printf("Timer %d fired\n", count);
23
    print_event_stats(base);
24

25
    if (count >= 5) {
26
        event_base_loopexit(base, NULL);
27
    }
28
}
29

30
int main() {
31
    struct event_base *base = event_base_new();
32

33
    printf("Initial state:\n");
34
    print_event_stats(base);
35

36
    // 创建多个定时器
37
    struct event *timers[3];
38
    for (int i = 0; i < 3; i++) {
39
        timers[i] = event_new(base, -1, EV_PERSIST, timer_cb, base);
40
        struct timeval tv = {i + 1, 0};
41
        event_add(timers[i], &tv);
42
    }
43

44
    printf("\nAfter adding timers:\n");
45
    print_event_stats(base);
46

47
    event_base_dispatch(base);
48

49
    printf("\nFinal state:\n");
50
    print_event_stats(base);
51

52
    for (int i = 0; i < 3; i++) {
53
        event_free(timers[i]);
54
    }
55
    event_base_free(base);
56

57
    return 0;
58
}

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <unistd.h>
4
#include <event2/event.h>
5

6
struct monitor_data {
7
    struct event_base *base;
8
    int check_interval;
9
};
10

11
static void monitor_cb(evutil_socket_t fd, short events, void *arg) {
12
    struct monitor_data *data = arg;
13

14
    int active = event_base_get_num_events(data->base, EVENT_BASE_COUNT_ACTIVE);
15
    int added = event_base_get_num_events(data->base, EVENT_BASE_COUNT_ADDED);
16
    int max_active = event_base_get_max_events(data->base, EVENT_BASE_COUNT_ACTIVE, 0);
17

18
    printf("[Monitor] Active: %d, Added: %d, Max Active: %d\n",
19
           active, added, max_active);
20
}
21

22
int main() {
23
    struct event_base *base = event_base_new();
24

25
    // 创建监控定时器
26
    struct monitor_data data = {base, 1};
27
    struct event *monitor = event_new(base, -1, EV_PERSIST, monitor_cb, &data);
28
    struct timeval tv = {1, 0};
29
    event_add(monitor, &tv);
30

31
    // 创建一些工作定时器
32
    for (int i = 0; i < 5; i++) {
33
        struct event *ev = event_new(base, -1, EV_PERSIST,
34
            [](evutil_socket_t fd, short events, void *arg) {}, NULL);
35
        struct timeval t = {0, (i + 1) * 200000};
36
        event_add(ev, &t);
37
    }
38

39
    // 运行10秒
40
    struct timeval exit_tv = {10, 0};
41
    event_base_loopexit(base, &exit_tv);
42

43
    event_base_dispatch(base);
44

45
    event_free(monitor);
46
    event_base_free(base);
47

48
    return 0;
49
}