Linux高并发服务器开发---笔记5（网络编程--＞I/O多路复用、项目实战1：阻塞/非阻塞、同步/异步、HTTP请求、响应报文、Reactor模式&Proactor模式、线程池原理）parse解析

Reus_try

已于 2022-08-13 14:58:18 修改

阅读量2.9k

点赞数 8

文章标签：服务器网络 linux

于 2022-07-20 06:45:05 首次发布

本文链接：https://blog.csdn.net/weixin_38665351/article/details/125718351

版权

0711

第4章项目制作与技能提升

4.0 视频课链接
4.1 项目介绍与环境搭建
4.2 Linux系统编程1、4.3 Linux系统编程2
4.4 多进程
- 1-9
- 10.进程间通信☆☆☆
4.5 多线程
4.6 网络编程1 & 4.7 网络编程2
4.8 项目实战1
4.9 项目实战2：线程池、epoll、读数据（分散读+自动增长的缓冲区）、写数据（分散写）

4.0 视频课链接

4.1 项目介绍与环境搭建

4.2 Linux系统编程1、4.3 Linux系统编程2

4.4 多进程

1-9

Linux高并发服务器开发—笔记1

10.进程间通信☆☆☆

见Linux高并发服务器开发—笔记2

4.5 多线程

见Linux高并发服务器开发—笔记3（多线程）

4.6 网络编程1 & 4.7 网络编程2

1-18

见Linux高并发服务器开发—笔记4（网络编程）

19的预备知识：TCP通信并发

讲I/O多路复用之前，先看TCP通信并发。

（视频课从01:17:30开始）
是不是跟②Linux简明系统编程（嵌入式公众号的课）—总课时12h中的 第26、27节课：并发服务器模型 concurrent_server 是一个意思？

第26、27节课讲两种并发服务器模型：

第26节课讲的是预先创建出几个新进程（fork()函数），然后等待客户端的请求。特点就是响应快，但如果请求多于预先创建的进程个数，就只能再排队了；（见示例1）
第27节课讲的是不预先创建新的进程，而是等客户端发来连接请求时，再创建线程/进程处理客户端的请求。特点就是响应慢，但有多少请求就创建多少线程/进程，这样不会出现资源的浪费或者资源不够的情况。（见示例2）

上面的示例1是提前创建好7个新的子进程，然后等待客户端的请求，请求来了就处理；
示例2是等待客户端的请求，请求来了就创建一个子进程，让子进程去处理请求；
接下来本节内容中有两个示例代码（将其命名为示例3和示例4），看了下这两个示例跟上面的示例2是一个思路，都是等请求来了再创建新进程或者新线程专门处理：
其中示例3是利用fork()函数创建一个子进程，然后让子进程去处理请求；
示例4是创建一个子线程，让子线程的线程函数去处理请求。

视频课的讲义：
要实现TCP通信服务器处理并发的任务，使用多线程或者多进程来解决。

思路：

一个父进程，多个子进程；
父进程负责等待并接受客户端的连接；
子进程：完成通信，每接受一个客户端连接，就创建一个子进程用于通信。

示例3代码 — 利用`fork()`函数创建一个子进程，然后让子进程去处理请求。

在这里插入图片描述

server_process.c

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

void recyleChild(int arg) {
   
    while(1) {
   
        int ret = waitpid(-1, NULL, WNOHANG);
        if(ret == -1) {
   
            // 所有的子进程都回收了
            break;
        }else if(ret == 0) {
   
            // 还有子进程活着
            break;
        } else if(ret > 0){
   
            // 被回收了
            printf("子进程 %d 被回收了\n", ret);
        }
    }
}

int main() {
   

    struct sigaction act;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    act.sa_handler = recyleChild;
    // 注册信号捕捉
    sigaction(SIGCHLD, &act, NULL);
    

    // 创建socket
    int lfd = socket(PF_INET, SOCK_STREAM, 0);
    if(lfd == -1){
   
        perror("socket");
        exit(-1);
    }

    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));
    if(ret == -1) {
   
        perror("bind");
        exit(-1);
    }

    // 监听
    ret = listen(lfd, 128);
    if(ret == -1) {
   
        perror("listen");
        exit(-1);
    }

    // 不断循环等待客户端连接
    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 is : %s, prot is %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("recv client : %s\n", recvBuf);
                } else if(len == 0) {
   
                    printf("client closed....\n");
                    break;
                }
                write(cfd, recvBuf, strlen(recvBuf) + 1);
            }
            close(cfd);
            exit(0);    // 退出当前子进程
        }

    }
    close(lfd);
    return 0;
}

client.c

// 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);
    if(fd == -1) {
   
        perror("socket");
        exit(-1);
    }

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

    if(ret == -1) {
   
        perror("connect");
        exit(-1);
    }
    
    // 3. 通信
    char recvBuf[1024];
    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("recv server : %s\n", recvBuf);
        } else if(len == 0) {
   
            // 表示服务器端断开连接
            printf("server closed...");
            break;
        }

        sleep(1);
    }

    // 关闭连接
    close(fd);

    return 0;
}

示例4代码 — 创建一个子线程，让子线程的线程函数去处理请求。

server_thread.c

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

struct sockInfo {
   
    int fd; // 通信的文件描述符
    struct sockaddr_in addr;
    pthread_t tid;  // 线程号
};

struct sockInfo sockinfos[128];

void * working(void * arg) {
   
    // 子线程和客户端通信   cfd 客户端的信息 线程号
    // 获取客户端的信息
    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 is : %s, prot is %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("recv client : %s\n", recvBuf);
        } else if(len == 0) {
   
            printf("client closed....\n");
            break;
        }
        write(pinfo->fd, recvBuf, strlen(recvBuf) + 1);
    }
    close(pinfo->fd);
    return NULL;
}

int main() {
   

    // 创建socket
    int lfd = socket(PF_INET, SOCK_STREAM, 0);
    if(lfd == -1){
   
        perror("socket");
        exit(-1);
    }

    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));
    if(ret == -1) {
   
        perror("bind");
        exit(-1);
    }

    // 监听
    ret = listen(lfd, 128);
    if(ret == -1) {
   
        perror("listen");
        exit(-1);
    }

    // 初始化数据
    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;
    }

    // 循环等待客户端连接，一旦一个客户端连接进来，就创建一个子线程进行通信
    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++) {
   
            // 从这个数组中找到一个可以用的sockInfo元素
            if(sockinfos[i].fd == -1) {
   
                pinfo = &sockinfos[i];
                break;
            }
            if(i == max - 1) {
   
                sleep(1);
                i--;
            }
        }

        pinfo->fd = cfd;
        memcpy(&pinfo->addr, &cliaddr, len);

        // 创建子线程
        pthread_create(&pinfo->tid, NULL, working, pinfo);

        pthread_detach(pinfo->tid);
    }

    close(lfd);
    return 0;
}

client.c

// 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);
    if(fd == -1) {
   
        perror("socket");
        exit(-1);
    }

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

    if(ret == -1) {
   
        perror("connect");
        exit(-1);
    }
    
    // 3. 通信
    char recvBuf[1024];
    int i = 0;
    while(1) {
   
        
        sprintf(recvBuf, "data : %d\n"

最低0.47元/天解锁文章

Reus_try

关注

8
点赞
踩
27

收藏

觉得还不错? 一键收藏
8
评论
Linux高并发服务器开发---笔记5（网络编程--＞I/O多路复用、项目实战1：阻塞/非阻塞、同步/异步、HTTP请求、响应报文、Reactor模式&Proactor模式、线程池原理）parse解析

Linux高并发服务器开发—笔记1这次答应我，一举拿下I/O多路复用！最基础的TCP的Socket编程，它是阻塞I/O模型，基本上只能一对一通信，那为了服务更多的客户端，我们需要改进网络I/O模型。比较传统的方式是使用多进程/线程模型，每来一个客户端连接，就分配一个进程/线程，然后后续的读写都在对应的进程/线程，这种方式处理100个客户端没问题，但是当客户端增大到10000个时，10000个进程/线程的调度、上下文切换以及它们占用的内存，都会成为瓶颈。I/O的多路复用。...................
复制链接

扫一扫