多路复用I/O模型select() 模型 代码实现

多路复用I/O:  socket编程之select(),poll(),epoll()

代码：

client.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <arpa/inet.h>
#include <assert.h>
#define maxn 1100
#define IP  "127.0.0.1"
#define PORT 45178
#define MAXLINE 1024
#define LISTENQ 5
#define SIZE 10
#define BACKLOG 2
int main()
{
    int sockfd;
    if((sockfd = socket(AF_INET,SOCK_STREAM,0)) == -1)
    {
        printf("socket error!
");
        exit(1);
    }
    struct sockaddr_in server;
    bzero(&server,sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(PORT);
    inet_pton(AF_INET,IP,&server.sin_addr);
    char buf[maxn];
    int connfd;
    connfd = connect(sockfd,(struct sockaddr*)&server,sizeof(server));
    if(connfd < 0)
    {
        printf("connect failure!
");
        return -1;
    }
    printf("client send to server
");
    printf("please input something
");
    scanf("%s",buf);
    write(sockfd,buf,maxn);
    char recvbuf[maxn];
    char sendbuf[maxn];
    fd_set readfd;
    int maxnum = 0;
    struct timeval T_time;
    int n;
    int sel_fd;
    while(1)
    {
        FD_ZERO(&readfd);
        FD_SET(sockfd,&readfd);
        maxnum = sockfd;
        T_time.tv_sec = 2;
        T_time.tv_usec = 0;
        sel_fd = select(maxnum + 1,&readfd,NULL,NULL,&T_time);
        if(sel_fd < 0)
        {
            continue;
        }
        else if(sel_fd == -1)
        {
            printf("select error!
");
            return;
        }
        if(FD_ISSET(sockfd,&readfd))
        {
            n = read(sockfd,recvbuf,maxn);
            if(n <= 0)
            {
                printf("server is closed!
");
                close(sockfd);
                FD_CLR(sockfd,&readfd);
                return;
            }
            printf("recv message is %s
", recvbuf);
            sleep(5);
            write(sockfd,buf,strlen(buf) + 1);
        }
    }
    close(sockfd);
    return 0;
}

server.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <arpa/inet.h>
#include <assert.h>
#define maxn 1100
#define PORT 45178
#define IP "127.0.0.1"
#define MAXLINE 1024
#define LISTENQ 5
#define SIZE 10
#define BACKLOG 2
typedef struct server_context_st
{
       int cli_num;        /*客户端个数*/
        int cli_fds[SIZE];   /*客户端的个数*/
      fd_set allfds;      /*句柄集合*/
        int maxfd;          /*句柄最大值*/
} server_context_st;

static int  init();
static void deal_maxfd(int sockfd);
static int accept_client(int sockfd);
static void recv_client_msg(fd_set *readfd);
static void submit_client_msg(int temp,char buf[]);
static server_context_st *server_client = NULL;
int Max(int a,int b);
int Max(int a,int b)
{
    return a>b?a:b;
}
static int server_init()
{
    server_client = (server_context_st *)malloc(sizeof(server_context_st));
    if(server_client == NULL)
    {
        return -1;
    }
    memset(server_client,0,sizeof(server_context_st));
    int i=0;
    for(;i<SIZE;i++)
    {
        server_client->cli_fds[i] = -1;
    }
    return 0;
}
static int  init()
{

    int sockfd;
    if((sockfd = socket(AF_INET,SOCK_STREAM,0)) == -1)
    {
        printf("socket error!
");
        exit(1);
    }
    int listenfd;
    struct sockaddr_in server;
    bzero(&server,sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(PORT);
    inet_pton(AF_INET,IP,&server.sin_addr);
    if(bind(sockfd,(struct sockaddr*)&server,sizeof(struct sockaddr)) == -1)
    {
        perror("bind error:");
        return -1;
    }
    listen(sockfd,BACKLOG);
    return sockfd;
}
static void deal_maxfd(int sockfd)
{
    fd_set *readfd = &server_client->allfds;
    int sel_fd = 0;
    int clifd = -1;
    struct timeval T_time;
    while(1)
    {
        FD_ZERO(readfd);
        FD_SET(sockfd,readfd);
        server_client->maxfd = sockfd;
        T_time.tv_sec = 30;
        T_time.tv_usec = 0;
        
        int i;
        for(i=0;i<server_client->cli_num;i++)
        {
            clifd = server_client->cli_fds[i];
            FD_SET(clifd,readfd);
            server_client->maxfd =  Max(clifd,server_client->maxfd);
        }
        //retval = select(s_srv_ctx->maxfd + 1, readfds, NULL, NULL, &tv);
        sel_fd  = select(server_client->maxfd+1,readfd,NULL,NULL,&T_time);
        if(sel_fd == 0)
        {
            printf("time out!
");
            continue;
        }
        else if(sel_fd == -1)
        {
            printf("something error!
");
            return ;
        }
        if(FD_ISSET(sockfd,readfd))
        {
            /*监听客户端请求*/
            accept_client(sockfd);
        }
        else
        {
            /*接受处理客户端消息*/
            recv_client_msg(readfd);
        }
    }
}
static int accept_client(int sockfd)
{
    struct sockaddr_in server_c;
    socklen_t len;
    len = sizeof (server_c);
    int afd = -1;
    Loop:
    printf("waiting ............................
");
    afd = accept(sockfd,(struct sockaddr*)&server_c,&len);
    if(afd == -1)
    {
        if(errno == EINTR)
        {
            goto Loop;
        }
        else
        {
             fprintf(stderr, "accept fail,error:%s
", strerror(errno));
            return -1;
        }
    }
    printf("accept successful!
");
    int i=0;
    for(i=0;i<SIZE;i++)
    {
        if(server_client->cli_fds[i] < 0)
        {
            server_client->cli_fds[i] = afd;
            server_client->cli_num ++;
            break;
        }
    }
    if(i == SIZE)
    {
        printf("too many client to accept!
");
        return -1;
    }
}
static void recv_client_msg(fd_set *readfd)
{
    int i=0;
    int temp;
    char buf[maxn];
    for(i=0;i<server_client->cli_num;i++)
    {
        temp = server_client->cli_fds[i];
        if(temp < 0)
        {
            continue;
        }
        if(FD_ISSET(temp,readfd))
        {
            int n = read(temp,buf,maxn);
            if(n <= 0)
            {
                FD_CLR(temp,&server_client->allfds);
                close(temp);
                server_client->cli_fds[i] = -1;
                continue;
            }
            submit_client_msg(temp,buf);
        }
    }
}
static void submit_client_msg(int temp,char buf[])
{
    assert(buf);
    printf("receive message is %s
",buf);
    write(temp,buf,strlen(buf)+1);
    return ;
}
int main()
{
    if(server_init() == -1)
    {
        printf("init error
");
        return -1;
    }
    int sockfd;
    sockfd = init();
    deal_maxfd(sockfd);
    close(sockfd);
    return 0;
}

结果：