多进程并发服务器

1 多进程并发服务器思路分析

2 多进程并发服务器代码实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <signal.h>
#include <errno.h>
#include <sys/wait.h>

// 信号捕捉回调函数
void CatchChild(int sigNum)
{
    while (waitpid(-1, NULL, WNOHANG) > 0);

    return;
}

int main()
{
    int ret = 0;
    int sfd = 0, cfd = 0;
    pid_t pid;

    // 注册信号捕捉函数
    struct sigaction act;
    act.sa_handler = CatchChild;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;

    ret = sigaction(SIGCHLD, &act, NULL);
    if (-1 == ret)
    {
        perror("sigaction error");
        exit(1);
    }

    sfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == sfd)
    {
        perror("socket error");
        exit(1);
    }

    struct sockaddr_in saddr, caddr;

    memset(&saddr, 0, sizeof(saddr));
    saddr.sin_family = AF_INET;
    saddr.sin_port   = htons(8000);
    saddr.sin_addr.s_addr = inet_addr("192.168.71.132");
    //saddr.sin_addr.s_addr = htonl(INADDR_ANY);
    //inet_pton(AF_INET, "192.168.71.132", &saddr.sin_addr.s_addr);

    ret = bind(sfd, (struct sockaddr*)&saddr, sizeof(saddr));
    if (-1 == ret)
    {
        perror("bind error");
        close(sfd);
        exit(1);
    }

    ret = listen(sfd, 5);
    if (-1 == ret)
    {
        perror("listen error");
        close(sfd);
        exit(1);
    }

    while (1)
    {
        socklen_t caddrLen = sizeof(caddr);
        cfd = accept(sfd, (struct sockaddr*)&caddr, &caddrLen);
        if (-1 == cfd)
        {
            if (errno == EINTR) // 慢速系统调用被信号中断
            {
                continue;
            }

            perror("accept error");
            exit(1);
        }
        else
        {
            printf("连接成功[%s:%d]\n", inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));
            pid = fork();
            if (pid < 0)
            {
                perror("fork error");
                exit(1);
            }
            else if (0 == pid)  // 子进程
            {
                close(sfd);
                break;
            }
            else    // 父进程
            {
                close(cfd);
                // 信号捕捉函数在此注册也可以
                continue;
            }
        }
    }
    
    if (pid == 0)   // 子进程
    {
        int n = 0;
        char buf[1024] = {0};
        while (1)
        {
        	// 通信只是将接收到的信息打印出来
            memset(buf, 0, sizeof(buf));
            n = read(cfd, buf, sizeof(buf));        // n = recv(cfd, buf, sizeof(buf), 0);
            if (-1 == n)
            {
                if (errno == EINTR)
                {
                    continue;
                }
                else
                {           
                    perror("read error\n");
                    close(cfd);
                    return -1;
                }
            }
            else if (0 == n)
            {
                printf("断开连接\n");
                close(cfd);
                return 0;
            }
            else
            {
                printf("%s\n", buf);
            }
        }

    }
    
    return 0;
}