ÒøºÓÀïµÄÐÇÐÇ

de</**
 * ¸ÃÎļþÃûΪepoll.c
 *
 * ¸Ã²âÊÔ´úÂëÊÇ´Óhttp://blog.csdn.net/mote_li/archive/2004/12/08/209450.aspxÐÞ¸ÄÀ´µÄ. Ö»¹©Ñ§Ï°Ê¹ÓÃ.
 *
 * ÎҵIJâÊÔ»·¾³AS4U3
 * [gan@localhost ~]$ uname -r
 * 2.6.9-34.EL
 */
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <stdio.h>
#include <strings.h>

#include <pthread.h>
 

#define MAXLINE 1024
#define OPEN_MAX 100
#define LISTENQ 20
#define INFTIM 1000

#define LOCAL_IP "192.168.1.101" /* ÐÞ¸ÄΪ×Ô¼º±¾µØ»úÆ÷¾Í¿ÉÒÔ²âÊÔÁË */
#define SERV_PORT 5555

/**
 * thread task link
 */
struct task
{
  int fd; /* file descriptor */
  struct task *next; /* next task */
};

struct user_data
{
  int fd;
  unsigned int n_size;
  char line[MAXLINE];
};

/* thread exec function */
void *readtask(void *args);
void *writetask(void *args);
 

/* declare epoll_event */
struct epoll_event ev, events[20];
int epfd;

pthread_mutex_t mutex; /* Ḭ̈߳²È«Ê¹Óà */
pthread_cond_t cond1; /* Ïß³ÌÌõ¼þµÈ´ýʹÓà */

struct task *readhead = NULL,
        *readtail = NULL,
        *writehead = NULL;

void setnonblocking(int sock)
{
  int opts;

  opts = fcntl(sock, F_GETFL);
  if(opts<0)
   {
     perror("fcntl(sock,GETFL)");
     exit(1); /* ÆäʵÕâÑù×ö²»ÔõôºÃ, ×îºÃ×Ô¼º×öºÃ³ö´í´¦ÀíµÄ¹¤×÷, ²»¹âÊǽø³ÌÍ˳ö¾Í¿ÉÒÔÁË */
   }

  if(fcntl(sock, F_SETFL, opts | O_NONBLOCK)<0)
   {
    perror("fcntl(sock,SETFL,opts)");
    exit(1);
   }
}

int main()
{
  int i, maxi, listenfd, connfd, sockfd, nfds;
  socklen_t clilen;
  pthread_t tid1,tid2;
  struct task *new_task=NULL;
  struct user_data *rdata=NULL;

  /* initialize the thread pool */
  pthread_mutex_init(&mutex, NULL);
  pthread_cond_init(&cond1, NULL);

   /* ´´½¨Ïß³Ì, ×îºÃ×öºÃ´íÎó´¦Àí¹¤×÷, ×Ô¼ºÒ²±È½ÏÀÁ. ÕæÕý×÷¶«Î÷ǧÍò±ðÕâÑùàÞ! */
  pthread_create(&tid1, NULL, readtask, NULL);
  pthread_create(&tid2, NULL, readtask, NULL);

   /* Éú³ÉÓÃÓÚ´¦ÀíacceptµÄepollרÓõÄÎļþÃèÊö·û
    * ÒÔÇ°´ÓûÓùý
    *

Create a new epoll file descriptor by requesting the kernel allocate an event backing store dimensioned[n. ³ß´ç, ³ß¶È, ά(Êý), ¶È(Êý), Ôª] for size descriptors. The size is not the maximum size of the backing store but just a hint to the kernel about how to dimension internal structures. The returned file descriptor will be used for all the subsequent calls to the epoll interface. The file descriptor returned by epoll_create must be closed by using POSIX::close.

When successful, epoll_create returns a positive integer identifying the descriptor. When an error occurs, epoll_create returns -1 and errno is set appropriately.

    *
    */
  epfd = epoll_create(256);

  struct sockaddr_in clientaddr;
  struct sockaddr_in serveraddr;

  listenfd = socket(AF_INET, SOCK_STREAM, 0);

  //°ÑsocketÉèÖÃΪ·Ç×èÈû·½Ê½

  setnonblocking(listenfd);

   //ÉèÖÃÓëÒª´¦ÀíµÄʼþÏà¹ØµÄÎļþÃèÊö·û

  ev.data.fd = listenfd;

   //ÉèÖÃÒª´¦ÀíµÄʼþÀàÐÍ

  ev.events = EPOLLIN | EPOLLET;

  /*×¢²áepollʼþ

Control an epoll descriptor, $epfd, by requesting the operation op be performed on the target file descriptor, fd.

$epfd is an epoll descriptor returned from epoll_create.
$op is one of EPOLL_CTL_ADD, EPOLL_CTL_MOD or EPOLL_CTL_DEL.
$fd is the file desciptor to be watched.
$eventmask is a bitmask of events defined by EPOLLIN, EPOLLOUT, etc.

When successful, epoll_ctl returns 0. When an error occurs, epoll_ctl returns -1 and errno is set appropriately.
   */
  epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);

  bzero(&serveraddr, sizeof(serveraddr));
  serveraddr.sin_family = AF_INET;

  char *local_addr = LOCAL_IP;
  inet_aton(local_addr, &(serveraddr.sin_addr));

  serveraddr.sin_port = htons(SERV_PORT);
  bind(listenfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));
  listen(listenfd, LISTENQ);

  maxi = 0;
  for ( ; ; )
   {
     /*µÈ´ýepollʼþµÄ·¢Éú

Wait for events on the epoll file descriptor $epfd.

$epfd is an epoll descriptor returned from epoll_create.
$maxevents is an integer specifying the maximum number of events to be returned.
$timeout is a timeout, in milliseconds

When successful, epoll_wait returns a reference to an array of events. Each event is a two element array, the first element being the file descriptor which triggered the event, and the second is the mask of event types triggered. For example, if epoll_wait returned the following data structure:

     */
     nfds = epoll_wait(epfd, events, 20, 500);

      //´¦ÀíËù·¢ÉúµÄËùÓÐʼþ

     for(i = 0; i < nfds; ++i)
      {
       if(events[i].data.fd == listenfd)
         {
         connfd = accept(listenfd, (struct sockaddr *)&clientaddr, &clilen);
         if(connfd < 0)
           {
          perror("connfd<0");
          exit(1);
           }

         setnonblocking(connfd);

         char *str = inet_ntoa(clientaddr.sin_addr);

         printf("connect_from >> %s \n", str);

         ev.data.fd = connfd; //ÉèÖÃÓÃÓÚ¶Á²Ù×÷µÄÎļþÃèÊö·û

         ev.events = EPOLLIN | EPOLLET; //ÉèÖÃÓÃÓÚ×¢²âµÄ¶Á²Ù×÷ʼþ


           //×¢²áev

         epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);
         }
       else if (events[i].events & EPOLLIN)
         {
          printf("reading!\n");

          if ((sockfd = events[i].data.fd) < 0)
            continue;

          new_task = (struct task *)malloc(sizeof(struct task));
          new_task->fd = sockfd;
          new_task->next = NULL;

          pthread_mutex_lock(&mutex); //Ìí¼ÓеĶÁÈÎÎñ


          if(readhead == NULL)
             {
             readhead = new_task;
             readtail = new_task;
             }
          else
             {
             readtail->next = new_task;
             readtail = new_task;
             }

              //»½ÐÑËùÓеȴýcond1Ìõ¼þµÄÏß³Ì

           pthread_cond_broadcast(&cond1);
           pthread_mutex_unlock(&mutex);
           }
        else if (events[i].events & EPOLLOUT)
          {
           rdata = (struct user_data *)events[i].data.ptr;
           sockfd = rdata->fd;

         printf("thread.%u Write data fd.%d len.%d data.%s \n"
        , (uint32_t)pthread_self(), sockfd, rdata->n_size, rdata->line);

           write(sockfd, rdata->line, rdata->n_size);
           close(sockfd);

           free(rdata);

           ev.data.fd = sockfd; //ÉèÖÃÓÃÓÚ¶Á²Ù×÷µÄÎļþÃèÊö·û

           ev.events = EPOLLIN | EPOLLET; //ÉèÖÃÓÃÓÚ×¢²âµÄ¶Á²Ù×÷ʼþ


              //ÐÞ¸ÄsockfdÉÏÒª´¦ÀíµÄʼþΪEPOLIN

           epoll_ctl(epfd, EPOLL_CTL_MOD, sockfd, &ev);
           }
       }
   }
}

/**
 * thread exec function
 */
void *readtask(void *args)
{
  int fd = -1;
  unsigned int n;

  //ÓÃÓڰѶÁ³öÀ´µÄÊý¾Ý´«µÝ³öÈ¥

  struct user_data *data = NULL;

  while (1)
   {
     pthread_mutex_lock(&mutex);

      //µÈ´ýµ½ÈÎÎñ¶ÓÁв»Îª¿Õ

     while(readhead == NULL)
      {
       printf("thread.%u waiting, task is NULL ... \n", (uint32_t)pthread_self());
       pthread_cond_wait(&cond1, &mutex);
      }

      fd = readhead->fd;

       //´ÓÈÎÎñ¶ÓÁÐÈ¡³öÒ»¸ö¶ÁÈÎÎñ

      struct task *tmp = readhead;
      readhead = readhead->next;
      free(tmp);

      pthread_mutex_unlock(&mutex);

      data = (struct user_data *)malloc(sizeof(struct user_data));
      data->fd = fd;

      if ((n = read(fd, data->line, MAXLINE)) < 0)
        {
        if (errno == ECONNRESET)
          {
           close(fd);
          }
        else
          printf("readline error \n");

        if(data != NULL)
           free(data);
        }
      else if (n == 0)
       {
       close(fd);
       printf("Client close connect!\n");
       if(data != NULL)
             free(data);
       }
     else
       {
       data->n_size = n;

       printf("thread.%u read fd.%d len.%d data.%s \n"
        , (uint32_t)pthread_self(), fd, n, data->line);
        
       ev.data.ptr = data; //ÉèÖÃÐèÒª´«µÝ³öÈ¥µÄÊý¾Ý

       ev.events = EPOLLOUT | EPOLLET; //ÉèÖÃÓÃÓÚ×¢²âµÄд²Ù×÷ʼþ


        //ÐÞ¸ÄsockfdÉÏÒª´¦ÀíµÄʼþΪEPOLLOUT

       epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev);
      }
   }
}


/**
 * Ò»¸ö¼òµ¥µÄMakefile
 */
all: epoll.c
        gcc -Wall -g -o epoll epoll.c -lpthread

clean:
        rm -f epollde<