libev事件库使用笔记

源码下载地址：http://dist.schmorp.de/libev/

libev是一个高性能的事件循环库，比libevent库的性能要好。

安装：

 tar -zxf libev-4.15.tar.gz
 cd libev-4.15
 ./configure
 make
 make install

设置环境变量：

设置一下环境变量(在文件/etc/profile中添加)。然后才可以运行。

 export LIBDIR=/usr/local/lib
 export LD_LIBRARY_PATH=/usr/local/lib
 export LD_RUN_PATH=/usr/local/lib

添加完成后运行：source  /etc/profile   使设置生效；

没有接触过libev的新手一般对概念也是比较蒙的，我也不多做介绍，教你如何快速上手

对比说明吧！

示例一：不使用libev

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#define DAEMON_PORT                8888
#define MAX_LISTEN                1024

char get_manager_ip[];

int adminserver();
void pthread_adminserver(int client_sd);

int main(int argc, char** argv){
    strcpy(get_manager_ip, argv[]);
    adminserver();
}
int adminserver()
{
    int ret = ;
    int i = ;
    int max = ;
    int nCurrentSocket = ;
    FILE *fp;
    int res;
    int client_sd;
    int server_sd;
    int reuse_addr;
    pthread_t p_tcpserver;
    int client_addr_size ;

    struct sockaddr_in client_addr;
    struct sockaddr_in server_addr;
    char line[];
    char listen_ip[];
    char cmd_ip[];

    char *pt;
    char *edit;

    sprintf(cmd_ip,"ifconfig %s |grep 'addr:' >/get_manager_ip",get_manager_ip);
    system(cmd_ip);

    fp = fopen("/get_manager_ip","rb");
    if (fp == NULL)
    {
        printf("Cann't open get_manger_ip file!\n");
        exit(-);
    }

    memset(line,,);
    fgets(line,,fp);
    fclose(fp);

    pt=strstr(line, "addr:");
    if (pt != NULL)
    {
        pt+=;
        edit=strtok(pt," ");
        strcpy(listen_ip,edit);
    }

    server_sd=socket( AF_INET, SOCK_STREAM,  );

    if (server_sd < )
    {
        printf("ERROR: Cann't create socket!!!\n");
        exit(-);
    }

    bzero(&server_addr, sizeof(struct sockaddr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr=inet_addr(listen_ip);
    server_addr.sin_port   = htons(DAEMON_PORT);  

    reuse_addr = ;
    if (setsockopt (server_sd, SOL_SOCKET, SO_REUSEADDR, &reuse_addr, sizeof(reuse_addr)) <  )
    {
        printf("setsockopt error\n");
        close(server_sd);
           return -;
    }

    res = bind(server_sd, (struct sockaddr *)&server_addr, sizeof(server_addr));
    if (res <  )
    {
        printf("Cann't bind!res = %d,erro:%d, reason:%s.\n",res, errno, strerror(errno));
        close(server_sd);
        exit(-);
    }  

    if (listen( server_sd, MAX_LISTEN ) !=  ) {
        printf("Cann't listen!\n");
        close(server_sd);
        exit(-);
    }

    while()
    {

        client_addr_size = sizeof(client_addr);
        client_sd = accept( server_sd, (struct sockaddr *)&client_addr, (socklen_t *)&client_addr_size);
        if (pthread_create(&p_tcpserver, NULL, (void *)&pthread_adminserver, client_sd)!=)
        {
            printf("Could not create thread check_work_time\n");
            return ;
        }
    }
    close(server_sd);
    exit();
}

void pthread_adminserver(int client_sd)
{
    int sockfd = ;
    int rc;
    char buffer[];
     while()
        {             //线程处理某个客户端的连接
            memset(buffer,,);
            rc=read(client_sd,buffer,);
            if(strlen(buffer) == ){
            close(client_sd);  //关闭线程处理的客户端连接
            pthread_exit();//终止该线程
            }
            printf("read date:\"%s\"\n",buffer);

        }
        close(client_sd);  //关闭线程处理的客户端连接
        pthread_exit();//终止该线程
}

说明：这是一个处理多并发的socket服务端，通过while接收多条连接，然后通过线程去处理每条连接，简单易懂，但是 使用两个while(1),是一件很浪费系统资源是事情；

示例二：通过示例一改动，添加libev

先对比两个示例先用起来吧，欢迎大神指导。

 #include <ev.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <netinet/in.h>
 #include <unistd.h>

 #define PORT 8080
 #define BUFFER_SIZE 1024
 #define MAX_CONNECTIONS 10

 struct ev_io *libevlist[MAX_CONNECTIONS] = {NULL};

 void socket_accept_callback(struct ev_loop *loop, struct ev_io *watcher, int revents);
 void socket_read_callback(struct ev_loop *loop, struct ev_io *watcher, int revents);
 /*
     Server                  Client

     socket                  socket
       |                       |
       v                       v
     bind                    connect
       |                       |
       v                       v
     listen                  write
       |                       |
       v                       v
     accept                  read
       |                       |
       v                       v
     read                    close
       |
       v
     write
       |
       v
     close
 */

 int main() {
     struct ev_loop *loop = ev_default_loop();

     /* socket start */
     int sd;
     struct sockaddr_in addr;
     int addr_len = sizeof(addr);

     struct ev_io *socket_watcher = (struct ev_io*)malloc(sizeof(struct ev_io));
     struct ev_timer *timeout_watcher = (struct ev_timer*)malloc(sizeof(struct ev_timer));

     // socket
     sd = socket(PF_INET, SOCK_STREAM, );
     if (sd < ) {
         printf("socket error\n");
         return -;
     }
     bzero(&addr, sizeof(addr));
     addr.sin_family = AF_INET;
     addr.sin_port = htons(PORT);
     addr.sin_addr.s_addr = INADDR_ANY;

     // bind
     if (bind(sd, (struct sockaddr*) &addr, sizeof(addr)) != ) {
         printf("bind error\n");
         return -;
     }
     // listen
     if (listen(sd, SOMAXCONN) < ) {
         printf("listen error\n");
         return -;
     }
     // set sd reuseful
     int bReuseaddr = ;
     if (setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, (const char*) &bReuseaddr, sizeof(bReuseaddr)) != ) {
         printf("setsockopt error in reuseaddr[%d]\n", sd);
         return -;
     }
     /* socket end */

     ev_io_init(socket_watcher, socket_accept_callback, sd, EV_READ);
     ev_io_start(loop, socket_watcher);

 //     while(1) {
         ev_run(loop, );
 //     }

     return ;
 }

 void socket_accept_callback(struct ev_loop *loop, struct ev_io *watcher, int revents) {
     printf("I am: %d\n", getpid());

     struct sockaddr_in client_addr;
     socklen_t client_len = sizeof(client_addr);
     int client_sd;

     if (EV_ERROR & revents) {
         printf("error event in accept\n");
         return;
     }

     // socket accept: get file description
     client_sd = accept(watcher->fd, (struct sockaddr*) &client_addr, &client_len);
     if (client_sd < ) {
         printf("accept error\n");
         return;
     }
     // too much connections
     if (client_sd > MAX_CONNECTIONS) {
         printf("fd too large[%d]\n", client_sd);
         close(client_sd);
         return;
     }

     if (libevlist[client_sd] != NULL) {
         printf("client_sd not NULL fd is [%d]\n", client_sd);
         return;
     }

     printf("client connected\n");
     // ev_io watcher for client
     struct ev_io *client_watcher = (struct ev_io*) malloc(sizeof(struct ev_io));
     if (client_watcher == NULL) {
         printf("malloc error in accept_cb\n");
         return;
     }
     // listen new client
     ev_io_init(client_watcher, socket_read_callback, client_sd, EV_READ);
     ev_io_start(loop, client_watcher);

     libevlist[client_sd] = client_watcher;
 }

 void socket_read_callback(struct ev_loop *loop, struct ev_io *watcher, int revents) {
     char buffer[BUFFER_SIZE];
     ssize_t read;

     if (EV_ERROR & revents) {
         printf("error event in read\n");
         return;
     }
     // socket recv
     read = recv(watcher->fd, buffer, BUFFER_SIZE, ); // read stream to buffer
     if (read < ) {
         printf("read error\n");
         return;
     }

     if (read == ) {
         printf("client disconnected.\n");

         if (libevlist[watcher->fd] == NULL) {
             printf("the fd already freed[%d]\n", watcher->fd);
         }
         else {
             printf("fd:%d will be closed!\n",watcher->fd);
             close(watcher->fd);
             ev_io_stop(loop, libevlist[watcher->fd]);
             free(libevlist[watcher->fd]);
             libevlist[watcher->fd] = NULL;
         }
         return;
     }
     else {
         printf("receive message[%d]says:%s\n",watcher->fd, buffer);
         if(memcmp(buffer,"quit",strlen("quit")) == )
         {
             printf("recv quit cmd,fd:%d will be closed!\n",watcher->fd);
             close(watcher->fd);
             ev_io_stop(loop, libevlist[watcher->fd]);
             free(libevlist[watcher->fd]);
             libevlist[watcher->fd] = NULL;
             return ;
         }
     }

     // socket send to client
     send(watcher->fd, buffer, read, );
     bzero(buffer, sizeof(buffer));
 }