TCP——并发服务

在上一节的程序中，服务端在进行到accept()环节会等待客户端的请求到来，若客户端一直不发生请求，则服务端会一直阻塞。

因此，引入并发服务器的概念。

　　一、并发服务器

　　同一时刻可以响应多个客户端的请求，多任务完成服务每个客户端的请求，每个客户端不需要排队等待，可以立即进行服务。

　　并发服务器设计技术一般有：多进程服务器、多线程服务器、I/O复用服务器(循环服务器)等。

　　

 　　

 　　(图片来源)

　　

　　1、多线程服务器

父进程监听客户端的连接请求，创建子线程，进行线程分离

子线程与客户端进行数据交互

　　多线程服务器是对多进程服务器的改进，由于多进程服务器在创建进程时要消耗较大的系统资源，所以用线程来取代进程，这样服务处理程序可以较快的创建。　　

　　优点： 服务效率高，客户端无需等待。
　　缺点： 复杂、较多地占用了系统的资源，一旦客户端过多会严重浪费系统资源。

　　

TCP多线程实例：

#include "net.h"
void cli_data_handle(void *arg);

int main()
{
    int fd = -1;
    struct sockaddr_in sin; //Internet环境下套接字的地址形式，对其进行操作以建立信息
    
    /*1、创建套接字描述符ｆｄ */
    if((fd = socket(AF_INET,SOCK_STREAM,0)) < 0)
    {
        perror("socket");
        exit(1);
    }

    /*2、将套接字绑定到一个本地地址与端口上*/
    
    /*2.1 填充struct sockaddr_in结构体变量*/
    bzero(&sin, sizeof(sin)); //初始值置零
    //sin_port和sin_addr都必须是NBD,且可视化的数字一般都是HBD,如端口号２３
    sin.sin_family = AF_INET; //协议，ipv4
    sin.sin_port   = htons(SERV_PORT); //将端口号转化为NBD

    /*优化１:让服务器能绑定在任意ＩＰ上*/
    sin.sin_addr.s_addr = htonl(INADDR_ANY);

    /*2.2 绑定 */
    if(bind(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0)
    {
        perror("bind");
        exit(1);
    }

    /*3. 把套接字设为监听模式，准备接收客户请求*/
    if(listen(fd, BACKLOG) < 0)
    {
        perror("listen");
        exit(1);
    }
    printf("Severing start...OK!
");

    /*4.等待客户请求到来，当请求到来后，接收请求，返回一个基于此次的新的套接字 */
    int newfd = -1;

    /*优化３:用多进程/多线程处理已经建立好连接的客户端数据*/
    pthread_t tid;

    struct sockaddr_in cin;
    socklen_t addrlen = sizeof(cin);
    while(1)
    {
        /*优化２:通过程序获取刚建立连接的socket的客户端的IP地址与端口号 */
        //获取客户端信息
        if((newfd = accept(fd, (struct sockaddr *)&cin, &addrlen))<0)
        {
            perror("accept");
            exit(1);
        }
        //读出客户端信息，并将HBD转为NBD
        char ipv4_addr[16];
        if(!inet_ntop(AF_INET, (void *)&cin.sin_addr,ipv4_addr,sizeof(cin)))
        {
            perror("inet_ntop");
            exit(1);
        }
        //打印客户端的IP和端口号
        printf("Client(%s,%d) is connected!
",ipv4_addr,ntohs(cin.sin_port));
        //打印完之后创建一个线程
        pthread_create(&tid, NULL, (void *)cli_data_handle, (void *)&newfd);
    }

    close(fd);
    return 0;

}

void cli_data_handle(void *arg)
{
    int newfd = *(int *)arg;

    printf("thread:newfd = %d
", newfd);

    /*5.　读写数据*/
    int ret = -1;
    char buf[BUFSIZ];

    while(1)
    {
    bzero(buf, BUFSIZ);
        do{
            ret = read(newfd, buf, BUFSIZ-1);
        }while(ret < 0 && EINTR == errno);
        if(ret < 0)
        {
            perror("read");
            exit(1);
        }

        if(!ret) //对方已经关闭
        {
            break;
        }
        printf("Receive data: %s",buf);

        if(!strncasecmp(buf,QUIT_STR, strlen(QUIT_STR)))
        {
            printf("Client is exiting!
");
            break;
        }
    }
    close(newfd);

}

/*运行方式：　./client serv_ip serv_port */
#include "net.h"

void usage(char *s)
{
    printf("
%s serv_ip serv_port
",s);
    printf("
	 serv_ip:serv ip address");
    printf("
	 serv_port: sever port(>5000)

");
}

int main(int argc, char **argv)
{
    int fd = -1;

    int port = -1;
    struct sockaddr_in sin;
    
    if(argc != 3)//参数错误检测
    {
        usage(argv[0]);
        exit(1);
    }
    /*1.创建sock fd */
    if((fd = socket(AF_INET,SOCK_STREAM,0)) < 0)
    {
        perror("socket");
        exit(1);
    }

    port = atoi(argv[2]);
    if(port < 5000)
    {
        usage(argv[0]);
        exit(1);
    }
    /*2.连接服务器 */
    /*2.1 填充struct sockaddr_in结构体变量*/
    bzero(&sin, sizeof(sin)); //初始值置零
    sin.sin_family = AF_INET; //
    sin.sin_port = htons(port); //转化为ＮＢＤ
#if 0
    sin.sin_addr.s_addr = inet_addr(SERV_IP_ADDR);
#else
    if(inet_pton(AF_INET, argv[1],(void *)&sin.sin_addr.s_addr) != 1)
    {
        perror("inet_pton");
        exit(1);
    }
#endif

    if(connect(fd,(struct sockaddr *)&sin, sizeof(sin)) < 0)
    {
        perror("connect");
        exit(1);
    }

    printf("Client starting ...
");

    /*3.读写数据*/
    char buf[BUFSIZ];
    int ret = -1;
    while(1)
    {
        bzero(buf,BUFSIZ);
        if(fgets(buf, BUFSIZ-1, stdin) == NULL)
        {
            continue;
        }
        do{
            ret = write(fd, buf, strlen(buf));
        }while(ret < 0 && EINTR == errno);
        if(!strncasecmp(buf, QUIT_STR, strlen(QUIT_STR)))
        {
            printf("Clinet is exiting!
");
            break;
        }

    }

    /*4.关闭套接字 */
    close(fd);

        return 0;
}

all:
    gcc  -o client client.c -lpthread
    gcc  -o pthread_tcp pthread_tcp.c -lpthread

clean:
    rm  *.elf

测试结果：

 2、多进程服务器

在多进程处理模型中

父进程主要用来监听客户端的连接请求，当有客户端请求连接时，accept()返回用于通信的文件描述符fd，父进程fock创建子进程，并负责回收子进程。
子进程获得父进程数据空间、堆和栈的复制品，拿到文件描述符fd后，和客户端进行数据交互。
通信结束后，子进程exit()结束，主进程进程资源的回收。

TCP多进程实例：

#include "net.h"
void cli_data_handle(void *arg);
void sig_child_handle(int signo)
{
    if(SIGCHLD == signo)
    {
        waitpid(-1, NULL, WNOHANG);
    }
}

int main()
{
    int fd = -1;
    struct sockaddr_in sin; //Internet环境下套接字的地址形式，对其进行操作以建立信息
    /*当客户端退出时，会通过信号机制回收子进程，防止变成僵尸进程*/    
    signal(SIGCHLD, sig_child_handle); //回收子进程

    /*1、创建套接字描述符ｆｄ */
    if((fd = socket(AF_INET,SOCK_STREAM,0)) < 0)
    {
        perror("socket");
        exit(1);
    }
    
    /*优化４：允许绑定地址快速重用*/
    int b_reuse = 1;
    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &b_reuse, sizeof(int));

    /*2、将套接字绑定到一个本地地址与端口上*/
    
    /*2.1 填充struct sockaddr_in结构体变量*/
    bzero(&sin, sizeof(sin)); //初始值置零
    //sin_port和sin_addr都必须是NBD,且可视化的数字一般都是HBD,如端口号２３
    sin.sin_family = AF_INET; //协议，ipv4
    sin.sin_port   = htons(SERV_PORT); //将端口号转化为NBD

    /*优化１:让服务器能绑定在任意ＩＰ上*/
    sin.sin_addr.s_addr = htonl(INADDR_ANY);

    /*2.2 绑定 */
    if(bind(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0)
    {
        perror("bind");
        exit(1);
    }

    /*3. 把套接字设为监听模式，准备接收客户请求*/
    if(listen(fd, BACKLOG) < 0)
    {
        perror("listen");
        exit(1);
    }
    printf("Severing start...OK!
");

    /*4.等待客户请求到来，当请求到来后，接收请求，返回一个基于此次的新的套接字 */
    int newfd = -1;

    struct sockaddr_in cin;
    socklen_t addrlen = sizeof(cin);
    while(1)
    {
        pid_t pid = -1;
        //获取客户端信息
        if((newfd = accept(fd, (struct sockaddr *)&cin, &addrlen)) < 0)
        {
            perror("accept");
            break;
        }
        /*创建一个子进程用于处理已经建立连接的客户的交互数据 */
        if((pid = fork()) < 0)
        {
            perror("fork");
            break;
        }

        if(0 == pid) //子进程
        {
            close(fd); //关闭不需要的文件描述符，节省资源
            //读出客户端信息，并将HBD转为NBD
            char ipv4_addr[16];
            if(!inet_ntop(AF_INET, (void *)&cin.sin_addr,ipv4_addr,sizeof(cin)))
            {
                perror("inet_ntop");
                exit(1);
            }
            
            //打印客户端的IP和端口号
            printf("Client(%s,%d) is connected!
",ipv4_addr,ntohs(cin.sin_port));
            cli_data_handle(&newfd);
            return 0; //客户端数据处理完毕，return跳出循环

        }else //pid > 0, 父进程
        {
            close(newfd); //关闭不需要的文件描述符
        }
    }
    close(fd);
    return 0;

}

void cli_data_handle(void *arg)
{
    int newfd = *(int *)arg;

    printf("Child handle process:newfd = %d
", newfd);

    /*5.　读写数据*/
    int ret = -1;
    char buf[BUFSIZ];

    while(1)
    {
    bzero(buf, BUFSIZ);
        do{
            ret = read(newfd, buf, BUFSIZ-1);
        }while(ret < 0 && EINTR == errno);
        if(ret < 0)
        {
            perror("read");
            exit(1);
        }

        if(!ret) //对方已经关闭
        {
            break;
        }
        printf("Receive data: %s",buf);

        if(!strncasecmp(buf,QUIT_STR, strlen(QUIT_STR)))
        {
            printf("Client is exiting!
");
            break;
        }
    }
    close(newfd);

}

/*运行方式：　./client serv_ip serv_port */
#include "net.h"

void usage(char *s)
{
    printf("
%s serv_ip serv_port
",s);
    printf("
	 serv_ip:serv ip address");
    printf("
	 serv_port: sever port(>5000)

");
}

int main(int argc, char **argv)
{
    int fd = -1;

    int port = -1;
    struct sockaddr_in sin;
    
    if(argc != 3)//参数错误检测
    {
        usage(argv[0]);
        exit(1);
    }
    /*1.创建sock fd */
    if((fd = socket(AF_INET,SOCK_STREAM,0)) < 0)
    {
        perror("socket");
        exit(1);
    }

    port = atoi(argv[2]);
    if(port < 5000)
    {
        usage(argv[0]);
        exit(1);
    }
    /*2.连接服务器 */
    /*2.1 填充struct sockaddr_in结构体变量*/
    bzero(&sin, sizeof(sin)); //初始值置零
    sin.sin_family = AF_INET; //
    sin.sin_port = htons(port); //转化为ＮＢＤ
#if 0
    sin.sin_addr.s_addr = inet_addr(SERV_IP_ADDR);
#else
    if(inet_pton(AF_INET, argv[1],(void *)&sin.sin_addr.s_addr) != 1)
    {
        perror("inet_pton");
        exit(1);
    }
#endif

    if(connect(fd,(struct sockaddr *)&sin, sizeof(sin)) < 0)
    {
        perror("connect");
        exit(1);
    }

    printf("Client starting ...
");

    /*3.读写数据*/
    char buf[BUFSIZ];
    int ret = -1;
    while(1)
    {
        bzero(buf,BUFSIZ);
        if(fgets(buf, BUFSIZ-1, stdin) == NULL)
        {
            continue;
        }
        do{
            ret = write(fd, buf, strlen(buf));
        }while(ret < 0 && EINTR == errno);
        if(!strncasecmp(buf, QUIT_STR, strlen(QUIT_STR)))
        {
            printf("Clinet is exiting!
");
            break;
        }

    }

    /*4.关闭套接字 */
    close(fd);

        return 0;
}

all:
    gcc  -o client client.c 
    gcc  -o process_tcp process_tcp.c 

clean:
    rm  *.elf

测试结果：