网络编程-tcp多客户端编程-多进程(6)

在前面的章节中讲到的编程模型中，和服务器通信的客户端最多只有一个，但是在实际应用场景中，大部分情况同时和服务器通信的客户端不止一个，因此需要用到其他技术来解决多客户端请求并发的问题。有三种方法来解决这个问题：
一、多进程模型
二、多线程模型
三、io多路复用技术
（1）多进程模型中，服务器接收到一个客户端连接请求时，然后创建一个进程，用子进程和客户端通信。通信结束后，父进程回收子进程资源即可。
（2）多线程模型中，服务器收到一个客户端连接请求时，然后创建一个线程，用子线程和客户端通信。通信结束后，父线程回收子线程的资源即可。
（3）io多路复用技术中，在linux系统常见的复用模型有select，poll，epoll。
多线程以及io多路复用后面的章节在详细介绍，下面贴出多进程模型的代码：

#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <resolv.h>
#include <sys/time.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/wait.h>
#include <sys/types.h>

const int MAXBUF = 1024;
const unsigned int MAXACCEPT = 2000;

//创建监听用的socket,传入监听的端口，
int tcpSocket(int port)
{
        int socketfd = socket(AF_INET, SOCK_STREAM, 0);
        struct sockaddr_in src;
        src.sin_family = AF_INET;
        src.sin_port = htons(port);
        src.sin_addr.s_addr = INADDR_ANY;
        memset(src.sin_zero, 0, sizeof(src.sin_zero));
        int ret = 0;
        ret = bind(socketfd, (struct sockaddr *)&src, sizeof(struct sockaddr_in));
        if (ret != 0)
        {
                printf("bind failed ret = %d\n", ret);
                close(socketfd);
                socketfd = 0;
                return 0;
        }
        listen(socketfd, 10000);
        return socketfd;
}

void sigHandler(int sig)
{
        // ctrl+c信号
        if(sig == SIGINT)
        {

        }
        // 子进程结束信号，父进程调用wait(0)回收资源
        if(sig == SIGCHLD)
        {
                wait(0);
        }
}

// 子进程通信函数，参数为通信socket
void socketProcess(int fd)
{
        char tmpStr[MAXBUF] = {0};
        while(1)
        {
                int ret = recv(fd, tmpStr, sizeof(tmpStr), MSG_DONTWAIT);
                if((ret < 0) && ((errno == EINTR) || (errno == EWOULDBLOCK) || (errno == EAGAIN)))
                {
                        continue;
                }
                else if(ret > 0)
                {
                        sprintf(tmpStr, "%s hello server: %s", tmpStr, __TIME__);
                        send(fd, tmpStr, sizeof(tmpStr), MSG_DONTWAIT);
                }
                else
                {
                        printf("close socket = %d\n", fd);
                        close(fd);
                        break;
                }
                memset(tmpStr, 0, sizeof(tmpStr));
        }
}

int main()
{
        //const int N = 1;
        int array;
        array = tcpSocket(10567);
        if (array == 0)
        {
                printf("bind failed\n");
        }

        signal(SIGINT, sigHandler);
        signal(SIGCHLD, sigHandler);

        int i = 0;
        while (1)
        {
                struct sockaddr dst;
                i++;
                unsigned int sockaddrLen = sizeof(struct sockaddr);

                int connectfd = accept(array, &dst, &sockaddrLen);
                if (connectfd <= 0)
                {
                        continue;
                }
                // 和客户端连接成功，创建子进程来处理和客户端的通信。
                pid_t pid = fork();
                if(pid < 0)
                {
                        printf("fork failed\n");
                        continue;
                }
                else if(pid == 0)
                {
                        socketProcess(connectfd);
                        break;
                }
                else 
                {
                        //通信socket被复制到父进程和子进程，子进程负责和客户端通信，则父进程中的socket需要关闭掉。
                        close(connectfd);
                }
        }
        return 0;
}