zoukankan      html  css  js  c++  java
  • Linux C语言 网络编程(二) server模型

    前面介绍了关于连接linux服务端方式,可是服务端的资源是有限的,所以我们通常须要又一次思考,设计一套server模型来处理相应的client的请求。

    第一种:并发server。通过主进程统一处理client的连接。当client连接过后。暂时fork()进程,由子进程处理client请求,将连接请求和业务进行了分离。

    server.c

    #include <sys/types.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <time.h>
    #include <string.h>
    #include <unistd.h>
    #include <stdio.h>
    #define BUFFLEN 1024
    #define SERVER_PORT 8888
    #define BACKLOG 5
    static void handle_request(int s_c)
    {
        time_t now;                                 /*时间*/
        char buff[BUFFLEN];                         /*收发数据缓冲区*/
        int n = 0;
        memset(buff, 0, BUFFLEN);                   /*清零*/
        n = recv(s_c, buff, BUFFLEN,0);         /*接收发送方数据*/
        if(n > 0 && !strncmp(buff, "TIME", 4))      /*推断是否合法接收数据*/
        {
            memset(buff, 0, BUFFLEN);               /*清零*/
            now = time(NULL);                       /*当前时间*/
            sprintf(buff, "%24s
    ",ctime(&now));  /*将时间复制入缓冲区*/
            send(s_c, buff, strlen(buff),0);        /*发送数据*/
        }       
        /*关闭client*/
        close(s_c); 
    }
    static int handle_connect(int s_s)
    {
    
        int s_c;                                /*client套接字文件描写叙述符*/
        struct sockaddr_in from;                /*client地址*/
        socklen_t len = sizeof(from);
    
        /*主处理过程*/
        while(1)
        {
            /*接收client连接*/
            s_c = accept(s_s, (struct sockaddr*)&from, &len);
            if(s_c > 0)                         /*client成功连接*/
            {
                /*创建进程进行数据处理*/
                if(fork() > 0){                 /*父进程*/
                    close(s_c);                 /*关闭父进程的client连接套接字*/
                }else{
                    handle_request(s_c);        /*处理连接请求*/
                    return(0);  
                }
            }
        }       
    }
    int main(int argc, char *argv[])
    {
        int s_s;                                /*server套接字文件描写叙述符*/
        struct sockaddr_in local;               /*本地地址*/    
    
        /*建立TCP套接字*/
        s_s = socket(AF_INET, SOCK_STREAM, 0);
    
        /*初始化地址*/
        memset(&local, 0, sizeof(local));       /*清零*/
        local.sin_family = AF_INET;             /*AF_INET协议族*/
        local.sin_addr.s_addr = htonl(INADDR_ANY);  /*随意本地地址*/
        local.sin_port = htons(SERVER_PORT);    /*serverport*/
    
        /*将套接字文件描写叙述符绑定到本地地址和port*/
        bind(s_s, (struct sockaddr*)&local, sizeof(local));
        listen(s_s, BACKLOG);               /*侦听*/
    
        /*处理client连接*/
        handle_connect(s_s);
    
        close(s_s);
    
        return 0;
    }
    

    代码比較具体,easy理解。

    以下介绍client代码,后面的client代码都是一样的。


    client.c

    #include <sys/types.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <string.h>
    #include <unistd.h>
    #include <stdio.h>
    #define BUFFLEN 1024
    #define SERVER_PORT 8888
    int main(int argc, char *argv[])
    {
        int s;                                      /*server套接字文件描写叙述符*/
        struct sockaddr_in server;                  /*本地地址*/
        char buff[BUFFLEN];                         /*收发数据缓冲区*/
        int n = 0;                                  /*接收字符串长度*/
    
        /*建立TCP套接字*/
        s = socket(AF_INET, SOCK_STREAM, 0);
    
        /*初始化地址*/
        memset(&server, 0, sizeof(server));     /*清零*/
        server.sin_family = AF_INET;                /*AF_INET协议族*/
        server.sin_addr.s_addr = htonl(INADDR_ANY);/*随意本地地址*/
        server.sin_port = htons(SERVER_PORT);       /*serverport*/   
    
        /*连接server*/
        connect(s, (struct sockaddr*)&server,sizeof(server));
        memset(buff, 0, BUFFLEN);                   /*清零*/
        strcpy(buff, "TIME");                       /*复制发送字符串*/
        /*发送数据*/
        send(s, buff, strlen(buff), 0);
        memset(buff, 0, BUFFLEN);                   /*清零*/
        /*接收数据*/    
        n = recv(s, buff, BUFFLEN, 0);
        /*打印消息*/
        if(n >0){
            printf("TIME:%s",buff); 
        }
        close(s);
    
        return 0;
    }

    另外一种模型:通过线程来处理,线程比进程占用资源少,效率高,数据共享。通过pthread_create()建立一个连接请求处理。线程处理函数为handle_request().
    server.c

    #include <sys/types.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <time.h>
    #include <string.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <pthread.h>
    #define BUFFLEN 1024
    #define SERVER_PORT 8888
    #define BACKLOG 5
    static void handle_request(void *argv)
    {
        int s_c = *((int*)argv);
        time_t now;                                 /*时间*/
        char buff[BUFFLEN];                         /*收发数据缓冲区*/
        int n = 0;
        memset(buff, 0, BUFFLEN);                   /*清零*/
        n = recv(s_c, buff, BUFFLEN,0);         /*接收发送方数据*/
        if(n > 0 && !strncmp(buff, "TIME", 4))      /*推断是否合法接收数据*/
        {
            memset(buff, 0, BUFFLEN);               /*清零*/
            now = time(NULL);                       /*当前时间*/
            sprintf(buff, "%24s
    ",ctime(&now));  /*将时间复制入缓冲区*/
            send(s_c, buff, strlen(buff),0);        /*发送数据*/
        }       
        /*关闭client*/
        close(s_c); 
    }
    static void handle_connect(int s_s)
    {
    
        int s_c;                                    /*client套接字文件描写叙述符*/
        struct sockaddr_in from;                    /*client地址*/
        socklen_t len = sizeof(from);
        pthread_t  thread_do;
    
        /*主处理过程*/
        while(1)
        {
            /*接收client连接*/
            s_c = accept(s_s, (struct sockaddr*)&from, &len);
            if(s_c > 0)                         /*client成功连接*/
            {
                /*创建线程处理连接*/
                pthread_create(&thread_do,
                        NULL,
                        (void*)handle_request,
                        &s_c);              
            }
        }       
    }
    int main(int argc, char *argv[])
    {
        int s_s;                                /*server套接字文件描写叙述符*/
        struct sockaddr_in local;               /*本地地址*/    
    
        /*建立TCP套接字*/
        s_s = socket(AF_INET, SOCK_STREAM, 0);
    
        /*初始化地址和port*/
        memset(&local, 0, sizeof(local));       /*清零*/
        local.sin_family = AF_INET;             /*AF_INET协议族*/
        local.sin_addr.s_addr = htonl(INADDR_ANY);  /*随意本地地址*/
        local.sin_port = htons(SERVER_PORT);        /*serverport*/
    
        /*将套接字文件描写叙述符绑定到本地地址和port*/
        bind(s_s, (struct sockaddr*)&local, sizeof(local));
        listen(s_s, BACKLOG);                   /*侦听*/
    
        /*处理client连接*/
        handle_connect(s_s);
    
        close(s_s);
    
        return 0;       
    }

    第三种:服务端各线程独自accept()。使用相互排斥锁,使用pthread_create()建立多个线程组成的线程池,主线程等待程序结束。各个线程独自接收clientaccept。以及后面数据处理。
    server.c

    #include <sys/types.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <time.h>
    #include <string.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <pthread.h>
    #define BUFFLEN 1024
    #define SERVER_PORT 8888
    #define BACKLOG 5
    #define CLIENTNUM 2
    /*相互排斥量*/
    pthread_mutex_t ALOCK = PTHREAD_MUTEX_INITIALIZER;
    static void *handle_request(void *argv)
    {   
        int s_s = *((int*)argv);
        int s_c;                                /*client套接字文件描写叙述符*/
        struct sockaddr_in from;                /*client地址*/
        socklen_t len = sizeof(from);
        for(;;)
        {
            time_t now;                         /*时间*/
            char buff[BUFFLEN];                 /*收发数据缓冲区*/
            int n = 0;
    
            pthread_mutex_lock(&ALOCK);         /*进入相互排斥区*/
            s_c = accept(s_s, (struct sockaddr*)&from, &len);
            /*接收client的请求*/
            pthread_mutex_unlock(&ALOCK);       /*离开相互排斥区*/
    
            memset(buff, 0, BUFFLEN);           /*清零*/
            n = recv(s_c, buff, BUFFLEN,0); /*接收发送方数据*/
            if(n > 0 && !strncmp(buff, "TIME", 4))  /*推断是否合法接收数据*/
            {
                memset(buff, 0, BUFFLEN);       /*清零*/
                now = time(NULL);               /*当前时间*/
                sprintf(buff, "%24s
    ",ctime(&now));  /*将时间复制入缓冲区*/
                send(s_c, buff, strlen(buff),0);        /*发送数据*/
            }       
            /*关闭client*/
            close(s_c); 
        }
    
        return NULL;
    }
    static void handle_connect(int s)
    {   
        int s_s = s;
        pthread_t  thread_do[CLIENTNUM];        /*线程ID*/
        int i = 0;
        for(i=0;i<CLIENTNUM;i++)                /*建立线程池*/
        {
            /*创建线程*/
            pthread_create(&thread_do[i],       /*线程ID*/
                        NULL,                   /*属性*/
                        handle_request,         /*线程回调函数*/
                        (void*)&s_s);           /*线程參数*/
        }
        /*等待线程结束*/
        for(i=0;i<CLIENTNUM;i++)
            pthread_join(thread_do[i], NULL);
    }
    int main(int argc, char *argv[])
    {
        int s_s;                                /*server套接字文件描写叙述符*/
        struct sockaddr_in local;               /*本地地址*/    
    
        /*建立TCP套接字*/
        s_s = socket(AF_INET, SOCK_STREAM, 0);
    
        /*初始化地址和port*/
        memset(&local, 0, sizeof(local));       /*清零*/
        local.sin_family = AF_INET;             /*AF_INET协议族*/
        local.sin_addr.s_addr = htonl(INADDR_ANY);  /*随意本地地址*/
        local.sin_port = htons(SERVER_PORT);        /*serverport*/
    
        /*将套接字文件描写叙述符绑定到本地地址和port*/
        bind(s_s, (struct sockaddr*)&local, sizeof(local));
        listen(s_s, BACKLOG);                   /*侦听*/
    
        /*处理client连接*/
        handle_connect(s_s);
    
        close(s_s);                                 /*关闭套接字*/
    
        return 0;
    }

    第四种:IO复用server。并发serverclient越多,对server造成的压力越大,所以还有第四种模型。IO复用函数用select来做。
    server.c

    #include <sys/types.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <time.h>
    #include <string.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <pthread.h>
    #include <sys/select.h>
    #define BUFFLEN 1024
    #define SERVER_PORT 8888
    #define BACKLOG 5
    #define CLIENTNUM 1024                      /*最大支持client数量*/
    
    /*可连接client的文件描写叙述符数组*/
    int connect_host[CLIENTNUM];
    int connect_number =  0;
    static void *handle_request(void *argv)
    {   
        time_t now;                                 /*时间*/
        char buff[BUFFLEN];                         /*收发数据缓冲区*/
        int n = 0;
    
        int maxfd = -1;                             /*最大侦听文件描写叙述符*/
        fd_set scanfd;                              /*侦听描写叙述符集合*/
        struct   timeval   timeout;                     /*超时*/
        timeout.tv_sec     =   1;                   /* 堵塞1s后超时返回 */     
        timeout.tv_usec   =   0;     
    
        int i = 0;
        int err  = -1;
        for(;;)
        {   
            /*最大文件描写叙述符值初始化为-1*/      
            maxfd = -1;
            FD_ZERO(&scanfd);                       /*清零文件描写叙述符集合*/
            for(i=0;i<CLIENTNUM;i++)                /*将文件描写叙述符放入集合*/
            {
                if(connect_host[i] != -1)           /*合法的文件描写叙述符*/
                {
                    FD_SET(connect_host[i], &scanfd);   /*放入集合*/
                    if(maxfd <  connect_host[i])    /*更新最大文件描写叙述符值*/
                    {
                        maxfd = connect_host[i];
                    }
                }
            }
            /*select等待*/
            err = select(maxfd + 1, &scanfd, NULL, NULL, &timeout) ;        
            switch(err)
            {
                case 0:                             /*超时*/
                    break;
                case -1:                            /*发生错误*/
                    break;
                default:                            /*有可读套接字文件描写叙述符*/
                    if(connect_number<=0)
                        break;
                    for(i = 0;i<CLIENTNUM;i++)
                    {
                        /*查找激活的文件描写叙述符*/
                        if(connect_host[i] != -1)
                        if(FD_ISSET(connect_host[i],&scanfd))   
                        {  
                            memset(buff, 0, BUFFLEN);/*清零*/
                            n = recv(connect_host[i], buff, BUFFLEN,0);
                            /*接收发送方数据*/
                            if(n > 0 && !strncmp(buff, "TIME", 4))
                            /*推断是否合法接收数据*/
                            {
                                memset(buff, 0, BUFFLEN);           /*清零*/
                                now = time(NULL);       /*当前时间*/
                                sprintf(buff, "%24s
    ",ctime(&now));
                                /*将时间复制入缓冲区*/
                                send(connect_host[i], buff, strlen(buff),0);
                                /*发送数据*/
                            }
                            /*更新文件描写叙述符在数组中的值*/
                            connect_host[i] = -1;
                            connect_number --;  /*client计数器减1*/    
                            /*关闭client*/
                            close(connect_host[i]);
                        } 
                    }
                    break;  
            }         
        } 
    
        return NULL;
    }
    static void *handle_connect(void *argv)
    {   
        int s_s = *((int*)argv) ;           /*获得server侦听套接字文件描写叙述符*/
        struct sockaddr_in from;
        socklen_t len = sizeof(from);
        /*接收client连接*/
        for(;;)
        {
            int i = 0;
            int s_c = accept(s_s, (struct sockaddr*)&from, &len);
            /*接收client的请求*/
            printf("a client connect, from:%s
    ",inet_ntoa(from.sin_addr));
            /*查找合适位置,将client的文件描写叙述符放入*/             
            for(i=0;i<CLIENTNUM;i++)
            {
                if(connect_host[i] == -1)           /*找到*/
                {
                    /*放入*/
                    connect_host[i]= s_c;
    
                    /*client计数器加1*/
                    connect_number ++;
                    /*继续轮询等待client连接*/
                    break;                      
                }   
            }       
        }   
        return NULL;
    }
    
    
    int main(int argc, char *argv[])
    {
        int s_s;                                /*server套接字文件描写叙述符*/
        struct sockaddr_in local;               /*本地地址*/    
        int i = 0;
        memset(connect_host, -1, CLIENTNUM);
    
        /*建立TCP套接字*/
        s_s = socket(AF_INET, SOCK_STREAM, 0);
    
        /*初始化地址*/
        memset(&local, 0, sizeof(local));           /*清零*/
        local.sin_family = AF_INET;                 /*AF_INET协议族*/
        local.sin_addr.s_addr = htonl(INADDR_ANY);  /*随意本地地址*/
        local.sin_port = htons(SERVER_PORT);        /*serverport*/
    
        /*将套接字文件描写叙述符绑定到本地地址和port*/
        bind(s_s, (struct sockaddr*)&local, sizeof(local));
        listen(s_s, BACKLOG);                   /*侦听*/
    
        pthread_t  thread_do[2];/*线程ID*/
        /*创建线程处理client连接*/
        pthread_create(&thread_do[0],               /*线程ID*/
                        NULL,                       /*属性*/
                        handle_connect,             /*线程回调函数*/
                        (void*)&s_s);               /*线程參数*/
        /*创建线程处理client请求*/                 
        pthread_create(&thread_do[1],               /*线程ID*/
                        NULL,                       /*属性*/
                        handle_request,             /*线程回调函数*/
                        NULL);                      /*线程參数*/
        /*等待线程结束*/
        for(i=0;i<2;i++)
            pthread_join(thread_do[i], NULL);
    
        close(s_s);
    
        return 0;
    }

    选择合适的server模型十分重要。对于编程有非常大的影响。

  • 相关阅读:
    Windows netstat 查看端口、进程占用
    nginx开启gzip
    linux查看内存
    linux查看进程、端口
    linux查看磁盘信息
    vmware克隆一台机器后修改etho
    java对象访问
    学生基本信息管理
    作业09-异常
    博客作业06--图
  • 原文地址:https://www.cnblogs.com/jzssuanfa/p/7267413.html
Copyright © 2011-2022 走看看