Linux:epoll

1.读事件：EPOLLIN
写事件：EPOLLOUT
send()一直就绪
recv()阻塞
发送缓冲区为空才能写，接受缓冲区有数据才能开始读
2.epoll服务器端代码：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<assert.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<sys/epoll.h>
#include<fcntl.h>
#include<errno.h>
#define MAX 10

void setnonblock(int fd)
{
    
    
    int oldfl=fcntl(fd,F_GETFL);
    int newfl=oldfl | O_NONBLOCK;
    if(fcntl(fd,F_SETFL,newfl)==-1)
  	{
    
    
		printf("fcntl error\n");
	}
}
void epoll_add(int epfd,int fd)
{
    
    
    struct epoll_event ev;
    ev.data.fd=fd;
    ev.events=EPOLLIN|EPOLLET;
    
    setnonblock(fd);//设置非阻塞
    
    if(epoll_ctl(epfd,EPOLL_CTL_ADD,fd,&ev)==-1)
    {
    
    
        perror("epoll ctl add err");
    }
}
void epoll_del(int epfd,int fd)
{
    
    
    if(epoll_ctl(epfd,EPOLL_CTL_DEL,fd,NULL)==-1)
    {
    
    
        perror("epoll ctl del err");
    }
}
int socket_init();
int main()
{
    
    
    int sockfd=socket_init();
    assert(sockfd!=-1);
    
    int epfd=epoll_create(MAX);//创建内核事件表-红黑树
    assert(epfd!=-1);
    
    epoll_add(epfd,sockfd);//将sockfd添加到内核时间表
    
    struct epoll_event evs[MAX];
    
    while(1)
    {
    
    
        int n=epoll_wait(epfd,evs,MAX,5000);
        if(n==-1)
        {
    
    
            continue;
        }
        else if(n==0)
        {
    
    
            printf("time out\n");
            continue;
        }
        else
        {
    
    
            for(int i=0;i<n;i++)
            {
    
    
                int fd=evs[i].data.fd;
                if(evs[i].events & EPOLLIN)
                {
    
    
                    if(fd==sockfd)//客户链接算一次
                    {
    
    
                        struct sockaddr_in caddr;
                        int len=sizeof(caddr);
                        int c=accept(fd,(struct sockaddr*)&caddr,&len);                    							if(c<0)
                        {
    
    
                        	continue;
                        }
                        printf("accept c=%d\n",c);
                        epoll_add(epfd,c);
     				}
                    else//客户发数据算一次
                    {
    
    
                        while(1)
                        {
    
    
                            char buff[128]={
    
    0};
                        	int num=recv(fd,buff,1,0);
                            if(num==-1)
                            {
    
    
                                if(errno==EAGAIN||errno==EWOULDBLOCK)
                                {
    
    
                                    send(fd,"ok",2,0);
                                }
                                else
                                {
    
    
                                	printf("recv error\n");
                                }
                                break;
                            }
                        	else if(num==0)//等于0，客户端关闭
                        	{
    
    
                        		epoll_del(epfd,fd);
                        		close(fd);
                        		printf("client close\n");
                                break;//跳出while循环
                        	}
                        	else
                        	{
    
    
                        		printf("buff=%s\n",buff);
                        	}
                        }
                    }
                }
            }
        }
    }
}
int socket_init()
{
    
    
    int sockfd=socket(AF_INET,SOCK_STREAM,0);//创建套接字
    if(sockfd==-1)
    {
    
    
        return -1;
    }
    
    struct sockaddr_in saddr;
    memset(&saddr,0,sizeof(saddr));
    saddr.sin_family=AF_INET;
    saddr.sin_port=htons(6000);
    saddr.sin_addr.s_addr=inet_addr("127.0.0.1");
    
    int res=bind(sockfd,(struct sockaddr*)&saddr,sizeof(saddr));
    if(res==-1)
    {
    
    
        return -1;
    }
    if(listen(sockfd,5)==-1)
    {
    
    
        return -1;
    }
    
    return sockfd;
}