libevent多线程

功能：

主线程同时监听定时器事件和IO事件，工作线程简单的监听IO事件。

主线程每隔一秒种向工作线程发送一条字符串信息

工作线程显示该信息并回显给主线程

该示例演示了主线程如何同时监听多个事件。

Makefile

1. eventtest : eventtest.c
2. gcc -Wall -g -levent -lpthread -o eventtest eventtest.c
3. .PHONY : clean
4. clean :
5. rm eventtest -f

eventtest.c

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <unistd.h>
   
4. #include <pthread.h>
   
5. 
   
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   
8. 
   
9. #include <event.h>
   
10. 
    
11. 
    
12. struct event_base *workerbase;
    
13. int fd[2];
    
14. 
    
15. static void 
    
16. thread_libevent_process(int fd, short which, void *arg)
    
17. {
    
18.     int ret;
    
19.     char buf[128];
    
20. 
    
21.     ret = read(fd, buf, 128);
    
22.     if (ret > 0) {
    
23.         buf[ret] = '\0';
    
24.         printf("thread receive message : %s\n", buf);
    
25.     }
    
26. 
    
27.     sleep(1);
    
28. 
    
29.     write(fd, buf, ret);
    
30. 
    
31. 
    
32.     return;
    
33. }
    
34. 
    
35. static void *
    
36. worker_thread(void *arg)
    
37. {
    
38.     int fd = *(int *)arg;
    
39. 
    
40.     struct event ev;
    
41. 
    
42.     event_set(&ev, fd, EV_READ | EV_PERSIST, thread_libevent_process, NULL);
    
43.     event_base_set(workerbase, &ev);
    
44.     event_add(&ev, 0);
    
45. 
    
46.     event_base_loop(workerbase, 0);
    
47. 
    
48. 
    
49.     return NULL;
    
50. }
    
51. 
    
52. static void
    
53. main_event_process(int fd, short which, void *arg)
    
54. {
    
55.     int ret;
    
56.     char buf[128];
    
57. 
    
58.     ret = read(fd, buf, 128);
    
59.     if (ret > 0) {
    
60.         buf[ret]='\0';
    
61.         printf("main thread receive echo message : %s\n", buf);
    
62.     }
    
63.     
    
64. 
    
65.     return;
    
66. }
    
67. 
    
68. static void
    
69. timeout_cb(int fdd, short event, void *arg)
    
70. {
    
71.     struct timeval tv;
    
72.     struct event *timeout = arg;
    
73. 
    
74.     write(fd[0], "Hello world!", sizeof("Hello world!") - 1);
    
75. 
    
76.     evutil_timerclear(&tv);
    
77.     tv.tv_sec = 1;
    
78.     event_add(timeout, &tv);
    
79. }
    
80. 
    
81. int
    
82. main (int argc, char *argv[])
    
83. {
    
84.     int ret;
    
85. 
    
86.     pthread_t tid;
    
87. 
    
88.     struct event ev;
    
89.     struct event evtimeout;
    
90.     struct timeval tv;
    
91. 
    
92.     struct event_base *base;
    
93. 
    
94.     base = event_init();
    
95.     if (base == NULL) {
    
96.         perror("event_init( base )");
    
97.         return 1;
    
98.     }
    
99. 
    
100.     workerbase = event_init();
     
101.     if (workerbase == NULL) {
     
102.         perror("event_init( workerbase )");
     
103.         return 1;
     
104.     }
     
105. 
     
106. 
     
107. 
     
108.     ret = socketpair(AF_LOCAL, SOCK_STREAM, 0, fd);
     
109.     if (ret == -1) {
     
110.         perror("socketpair() : ");
     
111.         return 1;
     
112.     }
     
113. 
     
114. 
     
115.     event_set(&ev, fd[0], EV_READ | EV_PERSIST, main_event_process, NULL);
     
116.     event_base_set(base, &ev);
     
117.     event_add(&ev, 0);
     
118. 
     
119.     evtimer_set(&evtimeout, timeout_cb, &evtimeout);
     
120.     event_base_set(base, &evtimeout);
     
121.     evutil_timerclear(&tv);
     
122.     tv.tv_sec = 1;
     
123.     event_add(&evtimeout, &tv);
     
124. 
     
125.     ret = pthread_create(&tid, NULL, worker_thread, (void *)&fd[1]);
     
126.     if (ret != 0) {
     
127.         perror("pthread_create()");
     
128.         return 1;
     
129.     }
     
130. 
     
131. 
     
132.     event_base_loop(base, 0);
     
133. 
     
134. 
     
135.     return 0;
     
136. }

libevent带负载均衡的多线程使用示例 

功能：

主线程根据负载工作线程负载均衡算法，每隔一秒钟向特定的工作线程发送一条字符串信息，工作线程简单的把字符串信息打开出来。

Makefile

1. eventtest : eventtest.c
2. gcc -Wall -g -levent -lpthread -o eventtest eventtest.c
3. .PHONY : clean
4. clean :
5. rm eventtest -f

eventtest.c

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <unistd.h>
   
4. #include <pthread.h>
   
5. 
   
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   
8. 
   
9. #include <event.h>
   
10. 
    
11. 
    
12. typedef struct {
    
13.     pthread_t tid;
    
14.     struct event_base *base;
    
15.     struct event event;
    
16.     int read_fd;
    
17.     int write_fd;
    
18. }LIBEVENT_THREAD;
    
19. 
    
20. typedef struct {
    
21.     pthread_t tid;
    
22.     struct event_base *base;
    
23. }DISPATCHER_THREAD;
    
24. 
    
25. 
    
26. const int thread_num = 10;
    
27. 
    
28. LIBEVENT_THREAD *threads;
    
29. DISPATCHER_THREAD dispatcher_thread;
    
30. int last_thread = 0;
    
31. 
    
32. 
    
33. 
    
34. static void
    
35. thread_libevent_process(int fd, short which, void *arg)
    
36. {
    
37.     int ret;
    
38.     char buf[128];
    
39.     LIBEVENT_THREAD *me = arg;
    
40. 
    
41.     if (fd != me->read_fd) {
    
42.         printf("thread_libevent_process error : fd != me->read_fd\n");
    
43.         exit(1);
    
44.     }
    
45. 
    
46.     ret = read(fd, buf, 128);
    
47.     if (ret > 0) {
    
48.         buf[ret] = '\0';
    
49.         printf("thread %llu receive message : %s\n", (unsigned long long)me->tid, buf);
    
50.     }
    
51. 
    
52. 
    
53.     return;
    
54. }
    
55. 
    
56. static void *
    
57. worker_thread(void *arg)
    
58. {
    
59.     LIBEVENT_THREAD *me = arg;
    
60.     me->tid = pthread_self();
    
61. 
    
62.     event_base_loop(me->base, 0);
    
63. 
    
64. 
    
65.     return NULL;
    
66. }
    
67. 
    
68. static void
    
69. timeout_cb(int fd, short event, void *arg)
    
70. {
    
71.     struct timeval tv;
    
72.     struct event *timeout = arg;
    
73. 
    
74.     int tid = (last_thread + 1) % thread_num;        //memcached中线程负载均衡算法
    
75. 
    
76.     LIBEVENT_THREAD *thread = threads + tid;
    
77. 
    
78.     last_thread = tid;
    
79. 
    
80.     write(thread->write_fd, "Hello world!", sizeof("Hello world!") - 1);
    
81. 
    
82.     evutil_timerclear(&tv);
    
83.     tv.tv_sec = 1;
    
84.     event_add(timeout, &tv);
    
85. }
    
86. 
    
87. int
    
88. main (int argc, char *argv[])
    
89. {
    
90.     int ret;
    
91.     int i;
    
92.     int fd[2];
    
93.     struct event timeout;
    
94.     struct timeval tv;
    
95. 
    
96.     pthread_t tid;
    
97. 
    
98.     dispatcher_thread.base = event_init();
    
99.     if (dispatcher_thread.base == NULL) {
    
100.         perror("event_init( base )");
     
101.         return 1;
     
102.     }
     
103.     dispatcher_thread.tid = pthread_self();
     
104. 
     
105. 
     
106.     threads = calloc(thread_num, sizeof(LIBEVENT_THREAD));
     
107.     if (threads == NULL) {
     
108.         perror("calloc");
     
109.         return 1;
     
110.     }
     
111. 
     
112.     for (i = 0; i < thread_num; i++) {
     
113.         
     
114.         ret = socketpair(AF_LOCAL, SOCK_STREAM, 0, fd);
     
115.         if (ret == -1) {
     
116.             perror("socketpair()");
     
117.             return 1;
     
118.         }
     
119. 
     
120.         threads[i].read_fd = fd[1];
     
121.         threads[i].write_fd = fd[0];
     
122. 
     
123.         threads[i].base = event_init();
     
124.         if (threads[i].base == NULL) {
     
125.             perror("event_init()");
     
126.             return 1;
     
127.         }
     
128. 
     
129. 
     
130.         event_set(&threads[i].event, threads[i].read_fd, EV_READ | EV_PERSIST, thread_libevent_process, &threads[i]);
     
131.         event_base_set(threads[i].base, &threads[i].event);
     
132.         if (event_add(&threads[i].event, 0) == -1) {
     
133.             perror("event_add()");
     
134.             return 1;
     
135.         }
     
136.     }
     
137. 
     
138.     for (i = 0; i < thread_num; i++) {
     
139.         pthread_create(&tid, NULL, worker_thread, &threads[i]);
     
140.     }
     
141. 
     
142.     evtimer_set(&timeout, timeout_cb, &timeout);
     
143.     event_base_set(dispatcher_thread.base, &timeout);
     
144.     evutil_timerclear(&tv);
     
145.     tv.tv_sec = 1;
     
146.     event_add(&timeout, &tv);
     
147. 
     
148.     event_base_loop(dispatcher_thread.base, 0);
     
149. 
     
150. 
     
151.     return 0;
     
152. }

libevent 简单例子，包括一个socket的

http://blog.chinaunix.net/uid-25885064-id-3399135.html