4.3-多进程/线程实现并发服务器

客户端

// TCP通信的客户端
#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

int main() {
    // 1. 创建套接字
    int fd = socket(AF_INET, SOCK_STREAM, 0);

    // 2. 连接服务器
    struct sockaddr_in serveraddr;
    serveraddr.sin_family = AF_INET;
    inet_pton(AF_INET, "10.37.62.58", &serveraddr.sin_addr.s_addr);
    serveraddr.sin_port = htons(9999);
    int ret = connect(fd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));

    // 3. 通信
    char recvBuf[1024] = {0};
    int i = 0;
    while (1) {
        sprintf(recvBuf, "data: %d\n", i++);
        write(fd, recvBuf, strlen(recvBuf) + 1);    // 带上字符串结束符

        int len = read(fd, recvBuf, sizeof(recvBuf));
        if (len == -1) {
            perror("read");
            exit(-1);
        }
        else if (len > 0) {
            printf("receive %s\n", recvBuf);
        }
        else if (len == 0) {    // 服务器端断开连接
            printf("server close\n");
            break;
        }
        sleep(1);
    }
    close(fd);  // 关闭连接
    return 0;
}

---

多进程实现并发服务器

// TCP通信的服务器端
#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/wait.h>
#include <errno.h>

void recycleChild(int arg) {
    while (1) {
        int ret = waitpid(-1, NULL, WNOHANG);   // 非阻塞
        if (ret == -1) {    // 所有子进程都回收了
            break;
        }
        else if (ret == 0) {    // 还有子进程活着
            break;
        }
        else if (ret > 0) {
            printf("recycle child process: %d\n", ret);
        }
    }
}

int main() {
    // 注册信号捕捉回收子进程资源
    struct sigaction act;
    act.sa_flags = 0;
    act.sa_handler = recycleChild;
    sigemptyset(&act.sa_mask);
    sigaction(SIGCHLD, &act, NULL);

    // 1. 创建用于监听的套接字
    int lfd = socket(PF_INET, SOCK_STREAM, 0);

    // 2. 绑定
    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(9999);
    saddr.sin_addr.s_addr = INADDR_ANY;
    int ret = bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));

    // 3. 监听
    ret = listen(lfd, 128);

    // 4. 循环等待接收客户端连接
    while (1) {
        struct sockaddr_in cliaddr;
        int len = sizeof(cliaddr);
        int cfd = accept(lfd, (struct sockaddr *)&cliaddr, &len);
        if (cfd == -1) {
            if (errno == EINTR) {
                continue;
            }
            perror("accept");
            exit(-1);
        }
        // 来一个连接就创建一个子进程
        pid_t pid = fork();
        if (pid == 0) {     // 子进程
            char cliIP[16]; // 获取客户端的信息
            inet_ntop(AF_INET, &cliaddr.sin_addr.s_addr, cliIP, sizeof(cliIP));
            unsigned short cliPort = ntohs(cliaddr.sin_port);
            printf("client IP: %s, Port: %d\n", cliIP, cliPort);

            char recvBuf[1024]; // 接收客户端数据
            while (1) {
                int len = read(cfd, recvBuf, sizeof(recvBuf));
                if (len == -1) {
                    perror("read");
                    exit(-1);
                }
                else if (len > 0) {
                    printf("receive %s\n", recvBuf);
                }
                else if (len == 0) {    // 客户端关闭了
                    printf("client close\n");
                    break;
                }
                write(cfd, recvBuf, strlen(recvBuf) + 1);   // 带上字符串结束符
            }
            close(cfd);
            exit(0);    // 子进程退出
        }
    }

    close(lfd);
    return 0;
}

---

多线程实现并发服务器

#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>
#include <errno.h>

// 把几个信息封装在一起，方便作为参数传递到线程处理函数
struct sockInfo {
    int fd; // 通信的文件描述符
    struct sockaddr_in addr;    // 客户端信息
    pthread_t tid;  // 线程号
};

struct sockInfo sockinfos[128]; // 固定子线程的数量

void* working(void *arg) {
    // 子线程和客户端通信
    struct sockInfo *pinfo = (struct sockInfo *)arg;
    char cliIP[16];
    inet_ntop(AF_INET, &pinfo->addr.sin_addr.s_addr, cliIP, sizeof(cliIP));
    unsigned short cliPort = ntohs(pinfo->addr.sin_port);
    printf("client IP: %s, Port: %d\n", cliIP, cliPort);

    char recvBuf[1024]; // 接收客户端数据
    while (1) {
        int len = read(pinfo->fd, recvBuf, sizeof(recvBuf));
        if (len == -1) {
            perror("read");
            exit(-1);
        }
        else if (len > 0) {
            printf("receive %s\n", recvBuf);
        }
        else if (len == 0) {
            printf("client close\n");
            break;
        }
        write(pinfo->fd, recvBuf, strlen(recvBuf) + 1);   // 带上字符串结束符
    }
    close(pinfo->fd);
    return NULL;
}

int main() {
    // 1. 创建用于监听的套接字
    int lfd = socket(PF_INET, SOCK_STREAM, 0);
    // 2. 绑定
    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(9999);
    saddr.sin_addr.s_addr = INADDR_ANY;
    int ret = bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));

    // 3. 监听
    ret = listen(lfd, 128);

    // 初始化数据
    int max = sizeof(sockinfos) / sizeof(sockinfos[0]); 
    for (int i = 0; i < max; i++) {
        bzero(&sockinfos[i], sizeof(sockinfos[i])); // 初始化结构体
        sockinfos[i].fd = -1;   // 初始化文件描述符
        sockinfos[i].tid = -1;  // 初始化线程id
    }

    // 4. 循环等待客户端连接，创建子线程
    while (1) {
        struct sockaddr_in cliaddr;
        int len = sizeof(cliaddr);
        int cfd = accept(lfd, (struct sockaddr *)&cliaddr, &len);

        struct sockInfo *pInfo;
        for (int i = 0; i < max; i++) {
            if (sockinfos[i].fd == -1) {
                pInfo = &sockinfos[i];  // 从数组中找到一个可用的sockInfo元素
                break;
            }
            if (i == max - 1) {
                sleep(1);
                i = -1;     // 没找到就再重头开始找
            }
        }
        pInfo->fd = cfd;
        memcpy(&pInfo->addr, &cliaddr, len);    // 拷贝结构体
        // 创建子线程
        pthread_create(&pInfo->tid, NULL, working, pInfo);
        // 线程分离
        pthread_detach(pInfo->tid);
    }
    close(lfd);

    return 0;
}