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

5
static void timer_cb(evutil_socket_t fd, short events, void *arg) {
6
    printf("Timer fired!\n");
7

8
    // 事件循环会自动退出，因为没有其他事件
9
}
10

11
int main() {
12
    struct event_base *base = event_base_new();
13

14
    // 创建一次性定时器（不带EV_PERSIST）
15
    struct event *timer = evtimer_new(base, timer_cb, NULL);
16

17
    // 设置3秒后触发
18
    struct timeval tv = {3, 0};
19
    evtimer_add(timer, &tv);
20

21
    printf("Timer set for 3 seconds...\n");
22

23
    event_base_dispatch(base);
24

25
    event_free(timer);
26
    event_base_free(base);
27

28
    return 0;
29
}

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

6
static int counter = 0;
7

8
static void timer_cb(evutil_socket_t fd, short events, void *arg) {
9
    counter++;
10
    printf("Timer fired! Count: %d\n", counter);
11

12
    if (counter >= 5) {
13
        printf("Reached 5 ticks, exiting...\n");
14
        struct event_base *base = arg;
15
        event_base_loopexit(base, NULL);
16
    }
17
}
18

19
static void signal_cb(evutil_socket_t fd, short events, void *arg) {
20
    struct event_base *base = arg;
21
    printf("Caught signal, exiting...\n");
22
    event_base_loopexit(base, NULL);
23
}
24

25
int main() {
26
    struct event_base *base = event_base_new();
27

28
    // 创建周期性定时器（带EV_PERSIST）
29
    struct event *timer = event_new(base, -1, EV_PERSIST, timer_cb, base);
30

31
    // 设置每1秒触发一次
32
    struct timeval tv = {1, 0};
33
    event_add(timer, &tv);
34

35
    // 信号处理
36
    struct event *sig = evsignal_new(base, SIGINT, signal_cb, base);
37
    event_add(sig, NULL);
38

39
    printf("Periodic timer started (1 second interval)\n");
40
    printf("Press Ctrl+C to exit\n");
41

42
    event_base_dispatch(base);
43

44
    event_free(sig);
45
    event_free(timer);
46
    event_base_free(base);
47

48
    return 0;
49
}

1
#include <stdio.h>
2
#include <event2/event.h>
3

4
static void precise_timer_cb(evutil_socket_t fd, short events, void *arg) {
5
    struct timeval now;
6
    evutil_gettimeofday(&now, NULL);
7

8
    printf("Timer at %ld.%06ld\n", now.tv_sec, now.tv_usec);
9
}
10

11
int main() {
12
    struct event_config *cfg = event_config_new();
13
    event_config_set_flag(cfg, EVENT_BASE_FLAG_PRECISE_TIMER);
14

15
    struct event_base *base = event_base_new_with_config(cfg);
16
    event_config_free(cfg);
17

18
    struct event *timer = event_new(base, -1, EV_PERSIST, precise_timer_cb, NULL);
19

20
    // 每100毫秒触发
21
    struct timeval tv = {0, 100000};
22
    event_add(timer, &tv);
23

24
    // 5秒后退出
25
    struct timeval exit_tv = {5, 0};
26
    event_base_loopexit(base, &exit_tv);
27

28
    event_base_dispatch(base);
29

30
    event_free(timer);
31
    event_base_free(base);
32

33
    return 0;
34
}

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

5
static void timer1_cb(evutil_socket_t fd, short events, void *arg) {
6
    printf("Timer 1: 1 second\n");
7
}
8

9
static void timer2_cb(evutil_socket_t fd, short events, void *arg) {
10
    printf("Timer 2: 2 seconds\n");
11
}
12

13
static void timer3_cb(evutil_socket_t fd, short events, void *arg) {
14
    printf("Timer 3: 3 seconds\n");
15
}
16

17
static void exit_cb(evutil_socket_t fd, short events, void *arg) {
18
    printf("Exit timer: exiting...\n");
19
    struct event_base *base = arg;
20
    event_base_loopexit(base, NULL);
21
}
22

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

26
    struct event *t1 = event_new(base, -1, EV_PERSIST, timer1_cb, NULL);
27
    struct event *t2 = event_new(base, -1, EV_PERSIST, timer2_cb, NULL);
28
    struct event *t3 = event_new(base, -1, EV_PERSIST, timer3_cb, NULL);
29
    struct event *exit_timer = evtimer_new(base, exit_cb, base);
30

31
    struct timeval tv1 = {1, 0};
32
    struct timeval tv2 = {2, 0};
33
    struct timeval tv3 = {3, 0};
34
    struct timeval tv_exit = {10, 0};
35

36
    event_add(t1, &tv1);
37
    event_add(t2, &tv2);
38
    event_add(t3, &tv3);
39
    event_add(exit_timer, &tv_exit);
40

41
    printf("Multiple timers started, will run for 10 seconds...\n");
42

43
    event_base_dispatch(base);
44

45
    event_free(t1);
46
    event_free(t2);
47
    event_free(t3);
48
    event_free(exit_timer);
49
    event_base_free(base);
50

51
    return 0;
52
}

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

5
static int interval = 1;
6

7
static void dynamic_timer_cb(evutil_socket_t fd, short events, void *arg) {
8
    struct event *timer = arg;
9

10
    printf("Timer fired with interval %d second(s)\n", interval);
11

12
    // 动态调整间隔
13
    interval++;
14
    if (interval > 5) {
15
        interval = 1;
16
    }
17

18
    // 重新设置定时器
19
    struct timeval tv = {interval, 0};
20
    event_add(timer, &tv);
21
}
22

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

26
    // 注意：不带EV_PERSIST，手动重新添加
27
    struct event *timer = event_new(base, -1, 0, dynamic_timer_cb, NULL);
28

29
    // 设置回调参数为timer本身
30
    event_assign(event_get_assignment(timer, &base, NULL, NULL, NULL, NULL),
31
                 base, -1, 0, dynamic_timer_cb, timer);
32

33
    struct timeval tv = {interval, 0};
34
    event_add(timer, &tv);
35

36
    // 20秒后退出
37
    struct timeval exit_tv = {20, 0};
38
    event_base_loopexit(base, &exit_tv);
39

40
    event_base_dispatch(base);
41

42
    event_free(timer);
43
    event_base_free(base);
44

45
    return 0;
46
}