「这是我参与2022首次更文挑战的第26天，活动详情查看：2022首次更文挑战」。

多进程并发服务器（server端）：

流程

 防止僵尸进程，捕捉SIGCHLD信号
 1、socket()  创建监听套接字 lfd : listen socket
 2、bind() 绑定地址结构  struct sockaddr_in addr;
 3、Listen() 
 4、while(1)
        cfd = Accept() 接受客户端连接请求
        pid = fork() 产生子进程
        if(pid == 0) // 子进程 (既有cfd ，又有 lfd)
            close(lfd); // 关闭用于建立连接的套接字
            read(cfd) 
            小写-->大写 
            write(cfd)
        else if(pid>0) // 父进程 （既有 cfd,又有 lfd）
            close(cfd); // 关闭用于和客户端建立连接的套接字 cfd
            
            waitpid(0,NULL,WNOHANG);
            continue;
5、 子进程：
        close(lfd)
        read(cfd)
        🔡 --》 🔠
        write()

    父进程：
        close(cfd);
        注册信号捕捉函数 ： SIGCHLD
        在回调函数中，完成子进程回收： while(waitpid());

代码

#include <ctype.h>
#include <strings.h>
#include <signal.h>
#include <sys/wait.h>

#include "wrap.c"

#define PORT 9090

void catch_child(int num)
{
    while (waitpid(0, NULL, WNOHANG) > 0)
        ;
}

int main(int arg, char argv[])
{
    int lfd, cfd;
    int i, ret;
    int pid;
    socklen_t serv_addr_len;
    char buf[BUFSIZ];
    
    lfd = Socket(AF_INET, SOCK_STREAM, 0);
    
    // 服务端地址结构、客户端地址结构
    struct sockaddr_in serv_addr, clit_addr;
    socklen_t clit_addr_len;
    clit_addr_len = sizeof(clit_addr_len);
    // 清空地址空间
    bzero(&serv_addr, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr_len = sizeof(serv_addr);
    // 绑定
    ret = Bind(lfd, (struct sockaddr *)&serv_addr, serv_addr_len);
    // 监听
    ret = Listen(lfd, 128);

    // 回收子进程，设置信号捕捉
    // 子进程状态发生变化时给父进程发送信号
    struct sigaction act;
    act.sa_handler = catch_child;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGCHLD, &act, NULL);

    while (1)
    {
        cfd = Accept(lfd, (struct sockaddr *)&clit_addr, &clit_addr_len);
        pid = fork();
        if (pid == 0) // 子进程
        {
            ret = Close(lfd);
            break;
        }
        else if (pid > 0) // 父进程
        {
            Close(cfd);
        }
        else
        {
            perror("fork error");
        }
    }

    // 子进程单独抠出来
    if (pid == 0)
    {
        while (1)
        {
            ret = Read(cfd, buf, sizeof(buf));
            if (ret == 0)
            {
                close(cfd);
                exit(1);
            }
            for (i = 0; i < ret; i++)
            {
                buf[i] = toupper(buf[i]);
            }
            // 写到屏幕
            write(STDOUT_FILENO, buf, ret);
            write(cfd, buf, ret);
        }
    }

    return 0;
}

多线程并发服务器（server端）

流程

使用线程分离

1、Socket()
2、Bind()
3、Listen()
4、while(1)
        cfd = Accept(lfd);
        pthread_create(&tid,NULL,tfn,NULL);
        pthread_detach(tid); // 设置子线程分离,不能获得子线程退出的状态
        // pthread_join(tid,void **); //可以回收子线程退出的状态，但是会产生阻塞。可以创建新线程，用于回收子线程（兄弟线程之间可以相互回收）
5、 子线程：
       void  *tfn(void *arg){
            close(lfd)
            read(cfd)
            🔡 --》 🔠
            write(cfd)
            pthread_exit(10); // 设置退出状态
       }

代码

#include <pthread.h>
#include <ctype.h>
#include <strings.h>
#include "wrap.c"
#define SERV_PORT 8000

#define MAXLINE 8192

// 将地址结构跟cfd绑定
struct s_info
{
    struct sockaddr_in clit_addr;
    int cfd;
};

void *tfn(void *arg)
{

    int n, i;
    struct s_info *ts = (struct s_info *)arg;
    char buf[MAXLINE];
    char str[INET_ADDRSTRLEN]; // 定义为 16
    while (1)
    {
        n = Read(ts->cfd, buf, MAXLINE);
        // 读取客户端
        if (n == 0) // 没有读到数据，说明客户端已经关闭
        {
            printf("the client %d closed ... \n", ts->cfd);
            break;
        }
        printf("received from %s at PORT %d\n",
               inet_ntop(AF_INET, &(*ts).clit_addr.sin_addr.s_addr, str, sizeof(str)),
               ntohs((*ts).clit_addr.sin_port));
        for (i = 0; i < n; i++)
        {
            buf[i] = toupper(buf[i]);
        }

        Write(STDOUT_FILENO, buf, n);
        Write(ts->cfd, buf, n);
    }
    Close(ts->cfd);

    return (void *)0;
}

int main()
{
    int lfd, cfd;
    int ret;
    struct s_info ts[256]; // 创建结构体数组
    int i = 0;
    pthread_t tid;

    struct sockaddr_in serv_addr, clit_addr;
    socklen_t serv_addr_len, clit_addr_len;

    serv_addr_len = sizeof(serv_addr);
    lfd = Socket(AF_INET, SOCK_STREAM, 0); // 创建一个 socket ，得到 listen_fd

    int opt = 1; //设置可以复用
    setsockopt(lfd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));

    // 地址结构清零
    bzero(&serv_addr, serv_addr_len);

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); // 指定本地任意IP
    serv_addr.sin_port = htons(SERV_PORT);         // 指定端口号

    ret = Bind(lfd, (struct sockaddr *)&serv_addr, serv_addr_len);
    ret = Listen(lfd, 128); // 设置同一时刻连接服务器的上限数

    printf("Accepting client connect ... \n");
    while (i < 10)
    {
        clit_addr_len = sizeof(clit_addr);

        cfd = Accept(lfd, (struct sockaddr *)&clit_addr, &clit_addr_len);
        ts[i].clit_addr = clit_addr;
        ts[i].cfd = cfd;

        pthread_create(&tid, NULL, tfn, (void *)&ts[i]);
        // 设置子线程分离，防止僵尸线程产生
        pthread_detach(tid);
        i++;
    }
    return 0;
}