进程池实现代码分块解析

于 2024-07-28 19:55:25 发布
阅读量653 收藏 7
点赞数 7
分类专栏： Linux 文章标签： 算法 linux ubuntu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cjsnzyq/article/details/140730242
版权

内部笔记——方便理解，自用（如有错误或不准确的地方请私信我，我会进行更正。）

分析代码——先看头文件中有哪些接口，再看调用关系。

#process_pool_bigfile.h

#ifndef __WD_FUNC_H
#define __WD_FUNC_H

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <errno.h>
#include <error.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <signal.h>
#include <dirent.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/epoll.h>
#include <assert.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <pthread.h>
#include <sys/uio.h>

#define SIZE(a) (sizeof(a)/sizeof(a[0]))

typedef void (*sighandler_t)(int);

#define ARGS_CHECK(argc, num)   {\
    if(argc != num){\
        fprintf(stderr, "ARGS ERROR!\n");\
        return -1;\
    }}

#define ERROR_CHECK(ret, num, msg) {\
    if(ret == num) {\
        perror(msg);\
        return -1;\
    }}

typedef enum {
    FREE,
    BUSY
}status_t;

typedef struct {
    int len;
    char buf[1000];
}train_t;


typedef struct {
    pid_t pid;//子进程的id
    int pipefd;//与子进程通信的管道
    status_t status;//0 空闲， 1 是忙碌
}process_data;

int makeChild(process_data *, int );
int doTask(int pipefd);

int sendFd(int pipefd, int fd);
int recvFd(int pipefd, int * pfd);

int tcpInit(const char * ip, unsigned short port);
int epollAddReadEvent(int epfd, int fd);
int epollDelReadEvent(int epfd, int fd);

int transferFile(int peerfd);

#endif

 分块解析：

1、各类头文件和宏函数

略

2、子进程状态结构体

typedef enum {
    FREE,
    BUSY
}status_t;

3、小火车结构体

解决TCP连接粘包问题的协议——小火车协议，在发送文件的基础上加一个int型占4个字节的长度信息

typedef struct {
    int len;
    char buf[1000];
}train_t;

4、子进程结构体

包含进程id、与父进程通信的管道的文件描述符、子进程的状态（空闲还是忙碌）

typedef struct {
    pid_t pid;//子进程的id
    int pipefd;//与子进程通信的管道
    status_t status;//0 空闲， 1 是忙碌
}process_data;

  •  5、各类函数接口

  1. 创建子进程——传入参数：子进程结构体，包含进程id、通信管道、当前状态。 
    int makeChild(process_data *, int );
  2. 执行子进程任务——参数：传入通信管道中的文件描述符（代指任务内容） 
    int doTask(int pipefd);
  3. 父子进程间传递文件描述符——父进程用sendFd将收到的客户端的任务fd传给管道，子进程再用recvFd从管道中将fd（pipefd)取出 
    int sendFd(int pipefd, int fd);
int recvFd(int pipefd, int * pfd);
  4. 与客户端建立tcp连接并让epoll的监督员epfd添加或删除读就绪事件 
    int tcpInit(const char * ip, unsigned short port);
int epollAddReadEvent(int epfd, int fd);
int epollDelReadEvent(int epfd, int fd);

  5. 传输文件数据

    int transferFile(int peerfd);

# main.c

#include "process_pool.h"
#include <signal.h>

int main(int argc, char ** argv)
{
    //ip port processnum
    ARGS_CHECK(argc, 4);
    int processNum = atoi(argv[3]);
    process_data * pProcess = calloc(processNum, sizeof(process_data));
    //让父子进程都忽略掉SIGPIPE信号
    signal(SIGPIPE, SIG_IGN);
    //创建N个子进程
    makeChild(pProcess, processNum);
    //makechild函数之后，都是父进程的操作

    //创建监听的服务器
    int listenfd = tcpInit(argv[1], atoi(argv[2]));

    //创建epoll的实例
    int epfd = epoll_create1(0);
    ERROR_CHECK(epfd, -1, "epfd");
    //epoll监听Listenfd
    epollAddReadEvent(epfd, listenfd);
    ///epoll监听父子进程间通信的管道
    for(int i = 0; i < processNum; ++i) {
        epollAddReadEvent(epfd, pProcess[i].pipefd);
    }
    //定义保存就绪的文件描述符的数组
    struct epoll_event eventArr[10] = {0};
    int nready = 0;

    while(1)
    {
        nready = epoll_wait(epfd, eventArr, sizeof(eventArr), -1);
        for(int i = 0; i < nready; ++i) {
            int fd = eventArr[i].data.fd; 
            //新客户端到来
            if(fd == listenfd) {
                struct sockaddr_in clientaddr;
                socklen_t len = sizeof(clientaddr);
                int peerfd = accept(listenfd, (struct sockaddr*)&clientaddr, &len);
                ERROR_CHECK(peerfd, -1, "accept");
                printf("client %s:%d connected.\n",
                       inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
                //将peerfd发送给一个空闲的子进程
                for(int j = 0; j < processNum; ++j) {
                    if(pProcess[j].status == FREE) {
                        sendFd(pProcess[j].pipefd, peerfd);
                        pProcess[j].status = BUSY;
                        break;
                    }
                }
                //如果要断开与客户端的连接，这里还得执行一次
                close(peerfd);
            } else {
                //管道发生了事件: 子进程已经执行完任务了
                int howmany = 0;
                read(fd, &howmany, sizeof(howmany));
                for(int j = 0; j < processNum; ++j) {
                    if(pProcess[j].pipefd == fd) {
                        pProcess[j].status = FREE;
                        printf("child %d is not busy.\n", pProcess[j].pid);
                        break;
                    }
                }

            }
        }
    }
    close(listenfd);
    close(epfd);

    return 0;
}

分块解析：

1、命令行参数校验。

利用头文件中的宏函数实现命令行参数的校验，如果输入的参数数量不对，则会报错退出

一共有四个参数：1、服务端IP地址，2、通信进程的端口号，3、需要预先创建的子进程数量

//ip port processnum
    ARGS_CHECK(argc, 4);

2、忽略SIGPIPE信号

由于客户端断开连接时，导致服务器中某一个子进程挂掉变成僵尸进程，导致父子进程通信的管道被关闭，而父进程一直监听该管道，会不断的监听到发出的SIGPIPE信号（表示管道已经损坏），父进程会误认为管道中依然有数据处于读就绪状态，于是epoll_wait函数不断返回，会有服务器疯狂打印的情况出现。

//让父子进程都忽略掉SIGPIPE信号
    signal(SIGPIPE, SIG_IGN);

3、创建N个子进程

封装函数makechild()创建多个子进程用来和客户端交互。

 //创建N个子进程
    makeChild(pProcess, processNum);

 //makechild函数之后，都是父进程的操作。

 4、监听服务器

创建listenfd套接字用来控制连接。

 //创建N个子进程
    makeChild(pProcess, processNum);

 5、在epoll监督公司聘请监督员epfd来监听事件

//创建epoll的实例
    int epfd = epoll_create1(0);
    ERROR_CHECK(epfd, -1, "epfd");

 6、监督员epfd监听listenfd（代指新连接也是新客户端）

epoll公司的epfd会监听连接和管道文件等内容是处于读就绪还是写就绪，根据相应的缓冲区的内容，如果是非空（有数据）就表示读就绪，如果是未满（有空间）就表示写就绪。

监听的底层原理就是在内核的红黑树上添加新结点。

//epoll监听Listenfd
    epollAddReadEvent(epfd, listenfd);

 7、监督员epfdl监听父子进程间通信的管道

///epoll监听父子进程间通信的管道
    for(int i = 0; i < processNum; ++i) {
        epollAddReadEvent(epfd, pProcess[i].pipefd);
    }

8、定义数组——保存就绪事件的文件描述符

数组类型为监听事件结构体struct epoll_event

 //定义保存就绪的文件描述符的数组
    struct epoll_event eventArr[10] = {0};
    int nready = 0;

 //开始处理事件任务

9、循环用epoll_wait函数，遍历，取符

在循环中epoll_wait函数阻塞，等待监听的就绪事件的文件描述符被挂上就绪链表，并返回就绪事件的个数，并遍历就绪事件，取得所有就绪事件的文件描述符。（fd是epoll监听的就绪链表上的文件描述符。

 while(1)
    {
        nready = epoll_wait(epfd, eventArr, sizeof(eventArr), -1);
        for(int i = 0; i < nready; ++i) {
            int fd = eventArr[i].data.fd;

分两种情况：

1、处理网络连接：新客户端到来，即有新连接，此时该就绪事件所对应的fd正好为服务器监听到的listenfd

2、 处理子进程状态变化（eg:已建立好连接的客户端的任务完成），此时fd不是服务器新监听到的listenfd而是本来就挂在就绪链表的就绪事件的文件描述符。

10、与客户端建立连接

定义网络地址的结构体并存储客户端的网络地址，并用accept函数接收返回与客户端进行交互的文件描述符peerfd

//新客户端到来
            if(fd == listenfd) {
                struct sockaddr_in clientaddr;
                socklen_t len = sizeof(clientaddr);
                int peerfd = accept(listenfd, (struct sockaddr*)&clientaddr, &len);
                ERROR_CHECK(peerfd, -1, "accept");
                printf("client %s:%d connected.\n",
                       inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));

 11、文件描述符传递

父进程在收到该连接成功后客户端的文件描述符peerfd后，通过sendFd函数将客户端文件描述符peerfd通过管道通信传递给一个子进程，实际上只发给管道的一端 ，

 //将peerfd发送给一个空闲的子进程
                for(int j = 0; j < processNum; ++j) {
                    if(pProcess[j].status == FREE) {
                        sendFd(pProcess[j].pipefd, peerfd);
                        pProcess[j].status = BUSY;
                        break;
                    }
                }

12、断开父进程和客户端之间的连接

此时父进程已经把客户端的文件描述符通过管道通信发给了子进程，已经下派完任务了，此时就不需要再和客户端保持着连接，所以要及时断开连接释放资源

 //如果要断开与客户端的连接，这里还得执行一次
                close(peerfd);

13、当子进程完成父进程下派的任务后，要更改子进程的状态，以便后续任务的下发

 } else {
                //管道发生了事件: 子进程已经执行完任务了
                int howmany = 0;
                read(fd, &howmany, sizeof(howmany));
                for(int j = 0; j < processNum; ++j) {
                    if(pProcess[j].pipefd == fd) {
                        pProcess[j].status = FREE;
                        printf("child %d is not busy.\n", pProcess[j].pid);
                        break;
                    }
                }

            }
        }
    }

14、关闭服务器时要释放资源

退出while循环时说明epoll公司的监督员epfd监听到的所有事件任务均处理完毕，内核中的红黑树和就绪链表为空了，若也无新连接到来的话，此时可以退出任务执行循环了，此时应令控制连接的listenfd和监督事件发生的epfd下班回家。

    close(listenfd);
    close(epfd);

    return 0;
}

编者的理解（仅供参考）：

一轮for循环处理一个客户端的任务，

当退出for循环时说明在进入循环时的就绪链表上的任务都处理完成了，

但每一轮while循环都会通过epoll_wait函数更新内核中红黑树的节点和就绪链表节点，每一处理完一个客户端任务后都会重新遍历更新后的就绪链表，

这样可以确保每次新到来的客户端连接任务能够被处理，

while被设计成死循环，保证服务器一直处于开启状态。

AI的理解（仅供参考）：

在这段代码中，`while`循环部分是事件循环，它不断监听并处理来自客户端的连接请求以及子进程之间的通信。具体来说，这段代码的作用是：

1. **等待事件发生 (`epoll_wait`)：** `epoll_wait` 函数会阻塞直到有文件描述符事件发生，然后将发生的事件存储在 `eventArr` 数组中。`nready` 保存了就绪的文件描述符的数量。

2. **遍历所有就绪的文件描述符：** 使用一个 `for` 循环遍历所有发生事件的文件描述符。

3. **处理新客户端的连接：** 
   - 如果发生事件的文件描述符是 `listenfd`（服务器监听的文件描述符），表示有新的客户端连接到来。
   - 使用 `accept` 接受新连接，并获取客户端地址信息。
   - 打印客户端的连接信息。
   - 将新连接的文件描述符 `peerfd` 发送给一个空闲的子进程进行处理（通过管道通信），并将该子进程的状态设置为忙碌。
   - 关闭 `peerfd`。

4. **处理子进程的状态变化：** 
   - 如果发生事件的是某个子进程的管道文件描述符，表示该子进程已经完成了任务。
   - 从管道中读取数据，并将相应子进程的状态设置为空闲。
   - 打印该子进程不再忙碌的消息。

这个循环使得服务器能够同时处理多个客户端连接，并且合理地分配任务给多个子进程。

函数接口解析：

#child.c

1、makeChild

#include "process_pool.h"

int makeChild(process_data * pProcess, int num)
{
    for(int i = 0; i < num; ++i) {
        int fds[2];
        socketpair(AF_LOCAL, SOCK_STREAM, 0, fds);
        pid_t pid = fork();
        if(pid == 0) {//子进程
            close(fds[1]);
            //子进程执行任务
            doTask(fds[0]);
            exit(0);
        } 
        //父进程
        close(fds[0]);
        //记录子进程的信息
        pProcess[i].pid = pid;
        pProcess[i].pipefd = fds[1];//与子进程通信的管道
        pProcess[i].status = FREE;
    }
    return 0;
}

int doTask(int pipefd)
{
    printf("proces %d is doTask...\n", getpid());
    while(1)
    {
        int peerfd = -1;
        //子进程不断地读取管道中传递过来的peerfd
        recvFd(pipefd, &peerfd);
        //发送文件的操作
        transferFile(peerfd);
        printf("child %d send finish.\n", getpid());

        //关闭peerfd
        close(peerfd);

        //通知父进程，任务执行完毕
        int one = 1;
        write(pipefd, &one, sizeof(one));
    }

    return 0;
}

makechild分块解析：（参数：(process_data * pProcess, int num)）

整个函数在一个for循环中，循环创建num个子进程和其与父进程之间的通信管道

int makeChild(process_data * pProcess, int num)
{
    for(int i = 0; i < num; ++i) {
……
}

1、创建全双工的套接字对fds[2]对作为通信管道

 int fds[2];
        socketpair(AF_LOCAL, SOCK_STREAM, 0, fds);

2、创建子进程并执行任务（使用全双工的套接字对要注意关闭不用的管道端）

pid_t pid = fork();
        if(pid == 0) {//子进程
            close(fds[1]);
            //子进程执行任务
            doTask(fds[0]);
            exit(0);
        }

 3、父进程记录子进程的信息

//父进程
        close(fds[0]);
        //记录子进程的信息
        pProcess[i].pid = pid;
        pProcess[i].pipefd = fds[1];//与子进程通信的管道
        pProcess[i].status = FREE;
    }
    return 0;
}

doTask分块解析：执行读操作完成父进程交代的任务，参数：（int pipefd）

整个函数在一个while（1）循环中

1、子进程不断地接收父进程从通信管道中传递来的文件描述符（任务），用peerfd接收

printf("proces %d is doTask...\n", getpid());
    while(1)
    {
        int peerfd = -1;
        //子进程不断地读取管道中传递过来的peerfd
        recvFd(pipefd, &peerfd);

2、发送文件操作（执行任务内容），并在执行完后关闭文件释放资源

 //发送文件的操作
        transferFile(peerfd);
        printf("child %d send finish.\n", getpid());

        //关闭peerfd
        close(peerfd);

3、任务执行完成后要通知父进程任务执行完毕

 //通知父进程，任务执行完毕
        int one = 1;
        write(pipefd, &one, sizeof(one));
    }

    return 0;
}

#transfer.c

函数中有两个函数：1、sendn函数用来确定发送的字节数是send函数的升级版

2、transferFile函数是用来传输文件数据的

#include "process_pool.h"

#define FILENAME "bigfile.avi"

//sendn函数可以发送确定的字节数
int sendn(int sockfd, const void * buff, int len)
{
    int left = len;
    const char* pbuf = buff;
    int ret = -1;
    while(left > 0) {
        ret = send(sockfd, pbuf, left, 0);
        if(ret < 0) {
            perror("send");
            return -1;
        }
        left -= ret;
        pbuf += ret;
    }
    return len - left;
}

int transferFile(int peerfd)
{
    //读取本地文件
    int fd = open(FILENAME, O_RDONLY);
    ERROR_CHECK(fd, -1, "open");
    //获取文件的长度
    struct stat st;
    memset(&st, 0, sizeof(st));
    fstat(fd, &st);
    char buff[100] = {0};
    int filelength = st.st_size;
    printf("filelength: %d\n", filelength);

    //进行发送操作
    //1. 发送文件名
    train_t t;
    memset(&t, 0, sizeof(t));
    t.len = strlen(FILENAME);
    strcpy(t.buf, FILENAME);
    sendn(peerfd, &t, 4 + t.len);
    
    //2. 再发送文件内容
    //2.1 发送文件的长度
    sendn(peerfd, &filelength, sizeof(filelength));

    int ret = 0;
    int total = 0;
    //2.2 再发送文件内容
    while(total < filelength) {
        memset(&t, 0, sizeof(t));
        ret = read(fd, t.buf, 1000);
        if(ret > 0) {
            t.len = ret;
            //sendn函数确保 4 + t.len 个字节的数据能正常发送
            ret = sendn(peerfd, &t, 4 + t.len);
            if(ret < 0) {
                printf(">> exit while not send.\n");
                break;//发生了错误,就退出while循环
            }
            total += (ret - 4);
        }
    }

    return 0;
}

sendn函数分块解析：

1、准备数据

left表示待发送的字节数

pbuf表示缓冲区用来存放数据的首地址

ret表示已发送的字节数

int left = len;
    const char* pbuf = buff;
    int ret = -1;

2、用send函数循环发送数据，利用left和ret的变化控制字节数的发送

while(left > 0) {
        ret = send(sockfd, pbuf, left, 0);
        if(ret < 0) {
            perror("send");
            return -1;
        }
        left -= ret;
        pbuf += ret;
    }
    return len - left;
}

transferFile函数分块解析：

1、打开本地文件

//读取本地文件
    int fd = open(FILENAME, O_RDONLY);
    ERROR_CHECK(fd, -1, "open");

2、获取文件长度——利用fstat函数来获取文件的状态信息（长度等）

//获取文件的长度
    struct stat st;
    memset(&st, 0, sizeof(st));
    fstat(fd, &st);
    char buff[100] = {0};
    int filelength = st.st_size;
    printf("filelength: %d\n", filelength);

3、进行发送操作

发送文件名

先定义小火车，初始化小火车的长度信息（文件名长度）和内容信息（文件名内容），再一并发送共4+t.len字节的信息

//进行发送操作
    //1. 发送文件名
    train_t t;
    memset(&t, 0, sizeof(t));
    t.len = strlen(FILENAME);
    strcpy(t.buf, FILENAME);
    sendn(peerfd, &t, 4 + t.len);

发送文件内容

其中要先发送文件长度

//2. 再发送文件内容
    //2.1 发送文件的长度
    sendn(peerfd, &filelength, sizeof(filelength));

再发送文件内容

使用read系统调用获取文件内容的字节数量，再用sendn发送文件内容完成任务。

    int ret = 0;
    int total = 0;
 //2.2 再发送文件内容
    while(total < filelength) {
        memset(&t, 0, sizeof(t));
        ret = read(fd, t.buf, 1000);
        if(ret > 0) {
            t.len = ret;
            //sendn函数确保 4 + t.len 个字节的数据能正常发送
            ret = sendn(peerfd, &t, 4 + t.len);
            if(ret < 0) {
                printf(">> exit while not send.\n");
                break;//发生了错误,就退出while循环
            }
            total += (ret - 4);
        }
    }

    return 0;
}

#server.c

包含三个函数：

1、建立tcp连接的tcpInit函数

2、添加监听读事件节点函数 epollAddReadEvent

3、删除监听读事件节点函数 epollDelReadEvent

#include "process_pool.h"

int tcpInit(const char * ip, unsigned short port)
{
    //创建服务器的监听套接字
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    ERROR_CHECK(listenfd, -1, "socket");

    //设置套接字的网络地址可以重用
    int on = 1;
    int ret = setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
    ERROR_CHECK(ret, -1, "setsockopt");

    struct sockaddr_in serveraddr;
    memset(&serveraddr, 0, sizeof(serveraddr));
    //指定使用的是IPv4的地址类型 AF_INET
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(port);
    serveraddr.sin_addr.s_addr = inet_addr(ip);

    //以人类可阅读的方式打印网络地址
    printf("%s:%d\n", 
           inet_ntoa(serveraddr.sin_addr),
           ntohs(serveraddr.sin_port));

    //绑定服务器的网络地址
    ret = bind(listenfd, (const struct sockaddr*)&serveraddr, 
                   sizeof(serveraddr));
    ERROR_CHECK(ret, -1, "bind");

    //监听客户端的到来
    ret = listen(listenfd, 1);
    ERROR_CHECK(ret, -1, "listen");

    return listenfd;
}

int epollAddReadEvent(int epfd, int fd)
{
    struct epoll_event ev;
    memset(&ev, 0, sizeof(ev));
    ev.events = EPOLLIN;
    ev.data.fd = fd;
    int ret = epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);
    ERROR_CHECK(ret, -1, "epoll_ctl");
    return 0;
}

int epollDelReadEvent(int epfd, int fd)
{
    struct epoll_event ev;
    memset(&ev, 0, sizeof(ev));
    ev.events = EPOLLIN;
    ev.data.fd = fd;
    int ret = epoll_ctl(epfd, EPOLL_CTL_DEL, fd, &ev);
    ERROR_CHECK(ret, -1, "epoll_ctl");
    return 0;
}

1、tcpInit函数分块解析

1、创建服务器监听套接字

int tcpInit(const char * ip, unsigned short port)
{
    //创建服务器的监听套接字
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    ERROR_CHECK(listenfd, -1, "socket");

2、设置套接字的网络地址可以重用

这是为了当服务器断开连接进入TIME——WAIT状态时，可以快速地再次启动服务器进程

//设置套接字的网络地址可以重用
    int on = 1;
    int ret = setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
    ERROR_CHECK(ret, -1, "setsockopt");

3、确定并存储服务端的网络地址

    struct sockaddr_in serveraddr;
    memset(&serveraddr, 0, sizeof(serveraddr));
    //指定使用的是IPv4的地址类型 AF_INET
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(port);
    serveraddr.sin_addr.s_addr = inet_addr(ip);

4、打印一下服务器网络地址用来交互显示

    //以人类可阅读的方式打印网络地址
    printf("%s:%d\n", 
           inet_ntoa(serveraddr.sin_addr),
           ntohs(serveraddr.sin_port));

5、绑定服务器的网络地址

    //绑定服务器的网络地址
    ret = bind(listenfd, (const struct sockaddr*)&serveraddr, 
                   sizeof(serveraddr));
    ERROR_CHECK(ret, -1, "bind");

6、监听客户端的到来

    //监听客户端的到来
    ret = listen(listenfd, 1);
    ERROR_CHECK(ret, -1, "listen");

    return listenfd;
}

2、epollAddReadEvent函数解析

1、创建监听事件结构体并初始化为读事件

int epollAddReadEvent(int epfd, int fd)
{
    struct epoll_event ev;
    memset(&ev, 0, sizeof(ev));
    ev.events = EPOLLIN;
    ev.data.fd = fd;

2、使用epoll_ctl函数在内核监听红黑树上添加该读事件节点

int ret = epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);
    ERROR_CHECK(ret, -1, "epoll_ctl");
    return 0;
}

2、epollDelReadEvent函数解析

1、创建监听事件结构体并初始化为读事件

int epollDelReadEvent(int epfd, int fd)
{
    struct epoll_event ev;
    memset(&ev, 0, sizeof(ev));
    ev.events = EPOLLIN;

2、使用epoll_ctl函数在内核监听红黑树上删除该读事件节点

 int ret = epoll_ctl(epfd, EPOLL_CTL_DEL, fd, &ev);
    ERROR_CHECK(ret, -1, "epoll_ctl");
    return 0;
}

#sendFd.c——用来实现管道通信传递文件描述符

共两个函数sendFd函数和recvFd函数

1、sendFd函数

1、构建msghdr结构体的第二组成员

int sendFd(int pipefd, int fd)
{
    //构建第二组成员
    char buff[6] = {0};
    struct iovec iov;
    memset(&iov, 0, sizeof(iov));
    iov.iov_base = buff;
    iov.iov_len = sizeof(buff);

2、构建msghdr结构体的第三组成员

    //构建第三组成员
    int len = CMSG_LEN(sizeof(fd));
    struct cmsghdr * pcmsg = 
        (struct cmsghdr*)calloc(1, len);
    pcmsg->cmsg_len = len;
    pcmsg->cmsg_level = SOL_SOCKET;
    pcmsg->cmsg_type = SCM_RIGHTS;
    int * p = (int*)CMSG_DATA(pcmsg);
    *p = fd;

3、构建msghdr结构体并用上面的成员初始化

    //构建msghdr
    struct msghdr msg;
    memset(&msg, 0, sizeof(msg));
    msg.msg_iov = &iov;
    msg.msg_iovlen = 1;
    msg.msg_control = pcmsg;//传递文件描述符
    msg.msg_controllen = len;

4、使用sendmsg函数将文件描述符发送至父子进程间的通信管道

   //sendmsg的返回值大于0时，就是iov传递的数据长度
    int ret = sendmsg(pipefd, &msg, 0);
    printf("sendmsg ret: %d\n", ret);
    ERROR_CHECK(ret, -1, "sendmsg");
    free(pcmsg);
    return 0;
}

2、recvFd函数

 1、构建msghdr结构体的第二组成员

int recvFd(int pipefd, int * pfd)
{
    //构建第二组成员
    char buff[6] = {0};
    struct iovec iov;
    memset(&iov, 0, sizeof(iov));
    iov.iov_base = buff;
    iov.iov_len = sizeof(buff);

2、构建msghdr结构体的第三组成员

    //构建第三组成员
    int len = CMSG_LEN(sizeof(int));
    struct cmsghdr * pcmsg = 
        (struct cmsghdr*)calloc(1, len);
    pcmsg->cmsg_len = len;
    pcmsg->cmsg_level = SOL_SOCKET;
    pcmsg->cmsg_type = SCM_RIGHTS;

3、构建msghdr结构体并用上面的成员初始化

    //构建一个struct msghdr
    struct msghdr msg;
    memset(&msg, 0, sizeof(msg));
    msg.msg_iov = &iov;
    msg.msg_iovlen = 1;
    msg.msg_control = pcmsg;//传递文件描述符
    msg.msg_controllen = len;

4、使用sendmsg函数将文件描述符发送至父子进程间的通信管道

    int ret = recvmsg(pipefd, &msg, 0);
    ERROR_CHECK(ret, -1, "recvmsg");
    int * p = (int*)CMSG_DATA(pcmsg);
    *pfd = *p;//读取文件描述符的值，并传给外界的变量
    return 0;
}

客户端代码：

#client.c

#include <func.h>

int main()
{
    //创建客户端的套接字
    int clientfd = socket(AF_INET, SOCK_STREAM, 0);
    ERROR_CHECK(clientfd, -1, "socket");

    struct sockaddr_in serveraddr;
    memset(&serveraddr, 0, sizeof(serveraddr));
    //指定使用的是IPv4的地址类型 AF_INET
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(8080);
    serveraddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    //连接服务器
    int ret = connect(clientfd, (struct sockaddr*)&serveraddr, 
                      sizeof(serveraddr));
    ERROR_CHECK(ret, -1, "connect");
    printf("connect success.\n");

    //进行文件的接收
    //1. 先接收文件的名字
    //1.1 先接收文件名的长度
    int length = 0;
    ret = recv(clientfd, &length, sizeof(length), 0);
    printf("filename length: %d\n", length);
    //1.2 再接收文件名本身
    char buff[1000] = {0};
    ret = recv(clientfd, buff, length, 0);
    printf("1 recv ret: %d\n", ret);
    int fd = open(buff, O_CREAT|O_RDWR, 0644);
    ERROR_CHECK(fd, -1, "open");

    //2. 再接收文件的内容
    //2.1 先接收文件内容的长度
    ret = recv(clientfd, &length, sizeof(length), 0);
    printf("fileconent length: %d\n", length);

    int total = 0;
    int len = 0;//每一个分片的长度
    //2.2 再接收文件内容本身
    while(total < length) {
        recv(clientfd, &len, sizeof(len), MSG_WAITALL);
        if(len != 1000) {
            printf("slice len: %d\n", len);
            //printf("total: %d bytes.\n", total);
        }
        memset(buff, 0, sizeof(buff));
        //将recv函数的第四个参数设置为MSG_WAITALL之后，
        //表示必须要接收len个字节的数据之后，才会返回
        ret = recv(clientfd, buff, len, MSG_WAITALL);// ret <= len
        //printf("slice %d bytes.\n", ret);
        if(ret > 0) {
            total += ret;
            write(fd, buff, ret);//写入本地文件
        }
    }

    close(fd);
    close(clientfd);

    return 0;
}

客户端main函数：

要点：

和服务端代码类似，步骤为：

  1. 创建客户端套接字
  2. 存储服务端网络地址
  3. 用connect函数连接服务器
  4. 进行文件的接收

先进行文件名的接收，再进行文件内容的接收，注意若文件内容较大时要将recv第四个参数设置为MSG_WAITALL来等待接收完全结束。

      5. 回收文件描述符

声明：未引入进程池退出机制，因为实在是太长了，改日再更！

其实是我还没学会，嘿嘿。

但是，岂有才情似沉阳？

勇敢阳阳，不怕困难！冲呀！

陈黎然
关注
  • 7
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
⭐⭐⭐⭐⭐Linux C++性能优化秘籍：从编译器到代码，探究高性能C++程序的实现之道
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
04-06 1790
高性能C++编程涉及多个方面，包括编译器优化、C++代码性能优化基本原则、C++对象管理与性能优化、多线程编程与性能优化、Linux系统调用优化等。通过学习和掌握这些要点，程序员可以有效地提高C++程序在Linux环境下的性能。接下来的章节将对这些核心要点进行详细的介绍。
一文详解Python中多进程和进程池的使用方法
Rocky006的博客
04-19 1800
Python是一种高级编程语言，它在众多编程语言中，拥有极高的人气和使用率。Python中的多进程和进程池是其强大的功能之一，可以让我们更加高效地利用CPU资源，提高程序的运行速度。本篇博客将介绍Python中多进程和进程池的使用方法，并提供一些实用的案例供读者参考。
[Python]基于进程的并行
seinelee的专栏
04-22 515
1 subprocess - 生成多余进程 subprocess目的是开始与其他进程交互，即用来生成子进程，并可以通过管道连接它们的输入/输出/错误，以及获得它们的返回值。 subprocess.run()函数是在python 3.5以后被添加的，具体参数列表参见python文档，下面只解释几个常用的参数描述。 subprocess.run(args, capture_out=False, s...
PHP进程系列
weixin_40048408的博客
09-27 219
1、PHP-FPM大概的进程模型——①：PHP-FPM启动进程的方式主要有哪几种，区别是什么？ PHP-FPM分为Static、Dynamic 2种进程启动方式 动态方式：会根据max、min、idle children 配置，动态的调整进程数量。在用户请求较为波动，或者瞬间请求增高的时候，进行大量进程的创建、销毁等操作，而造成Linux负载波动升高，简单来说，请求量少，PHP-FPM...
JVM内存分块详解
Programming Notes By Calm
11-28 645
JVM内存分块详解 作者：angus_17 原文：http://blog.csdn.net/angus_17/article/details/7018274 一、JVM内存区域组成 java把内存分四种： 1、栈区（stack segment）：由编译器自动分配释放，存放函数的参数值，局部变量的值等，具体方法执行结束之后，系统自动释放内存资源； 2、堆区（heap segmen
Java代码运行内存溢出详解及解决方案
jianghuchuanke的博客
04-17 5858
内存溢出与数据库锁表的问题，可以说是开发人员的噩梦，一般的程序异常，总是可以知道在什么时候或是在什么操作步骤上出现了异常，而且根据堆栈信息也很容易定位到程序中是某处出现了问题。内存溢出与锁表则不然，一般现象是操作一般时间后系统越来越慢，直到死机，但并不能明确是在什么操作上出现的，发生的时间点也没有规律，查看日志或查看数据库也不能定位出问题的代码。更严重的是内存溢出与数据库锁表在系统开发和单元测试阶...
python2.7异步_Python2.7实现多进程下开发多线程示例
weixin_39793319的博客
12-09 831
简单的基于Python2.7版本的多进程下开发多线程的示例，供大家参考，具体内容如下可以使得程序执行效率至少提升10倍#!/usr/bin/env python# -*- coding: utf-8 -*-"""@Time : 2018/10/24@Author : LiuXueWen@Site :@File : transfer.py@Software: PyCharm@Description:...
160多个android开源代码汇总
天道酬勤
11-30 1213
第一部分 个性化控件(View) 主要介绍那些不错个性化的View，包括ListView、ActionBar、Menu、ViewPager、Gallery、GridView、ImageView、ProgressBar、TextView、ScrollView、TimeView、TipView、FlipView、ColorPickView、GraphView、UI Style等等。 、其他
Python实现多线程下载脚本的示例代码
09-17
本文将详细解析如何使用Python实现多线程下载脚本，以提高下载效率。 首先，我们需要理解多线程的概念。线程是操作系统分配CPU时间的基本单位，一个进程可以有多个线程同时执行任务。在下载场景下，多线程可以并发...
处理文本文件的程序代码.zip
12-27
- Python的`concurrent.futures`库提供了线程池和进程池，简化了并发编程。 8. Unicode编码： - 处理文本文件时，需注意字符编码问题，如UTF-8、GBK等。使用`open()`时，通过`encoding`参数指定编码。 9. 错误...
netdisk-fast-download强大的网盘直链解析工具源码
01-11
这需要理解并发编程概念，熟悉线程池（threading模块）或进程池（multiprocessing模块）的使用。 3. **文件分块下载**：对于大文件，工具可能支持分块下载，然后在本地合并。这需要了解文件操作，如断点续传和文件...
python爬虫python-file-transfer.rar
05-30
Python的concurrent.futures模块提供了线程池和进程池的接口，简化了并发编程。例如，使用ThreadPoolExecutor可并行下载多个文件： ```python from concurrent.futures import ThreadPoolExecutor def download_...
如何在开发板上显示png图片1
08-08
如果内存资源有限，可能需要考虑分块加载或内存池管理等策略。 总之，要在GEC210开发板上显示PNG图片，关键在于正确移植和使用libpng及zlib库，以及编写适当的代码来解析和显示图像。这个过程涉及到了嵌入式系统的...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 867
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
2.6基本算法之动态规划6045:开餐馆
最新发布
Andy_SCP001的博客
07-24 170
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
cf场+线性dp
xxx_jsu的博客
07-23 328
令a[1]=x[1]+1后我们可以让a[i+1]=a[i]+x[i]，但是这样的话数可能会比较小，所以我们可以累加a[i]，因为是mod所以只要不大于x[i+1]可以一直加下去。2.n>b-a>0这种情况我们还需要考虑到使用到的a，在此之前我们按照等差数列出售了(b-a)个，那么剩下n-(b-a)个我们则需要按照a来出售。采用双指针，一个指向a的头部，一个指向b的头部，两者开始进行匹配，若相同则b往下走一位，否则就终止。题目的第一问其实就是让我们求最长不上升子序列，第二问就是求有多少段最长不上升序列。
算法-KMP字符串匹配
xx_xb的博客
07-23 253
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
2766. 重新放置石块 Medium
珞米的博客
07-24 502
第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，有石块的位置为 [2,2,3,3]。第 i = 1 步操作中，我们将位置 3 处的石块移到位置 2 处，有石块的位置为 [2,2,2,2]。第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，位置 2,6,7,8 有石块。第 i = 1 步操作中，我们将位置 7 处的石块移到位置 9 处，位置 2,6,8,9 有石块。第 i = 2 步操作中，我们将位置 2 处的石块移到位置 5 处，位置 5,6,8,9 有石块。
python 进程池代码
06-04
Python进程池是一种实现多进程的方法，它可以在多个进程之间分配任务，从而加快程序的运行速度。下面是一个简单的Python进程池示例代码： ```python import multiprocessing def worker(num): """每个进程将要运行的任务""" print('Worker %s is running' % num) if __name__ == '__main__': # 创建一个进程池，其中有4个进程 pool = multiprocessing.Pool(processes=4) # 运行10个任务，这些任务将会在4个进程之间分配 for i in range(10): pool.apply_async(worker, args=(i,)) # 关闭进程池 pool.close() # 等待所有任务完成 pool.join() ``` 上面的代码中，首先我们定义了一个`worker`函数，它表示每个进程将要运行的任务。然后我们创建了一个进程池，其中有4个进程。接着我们使用`apply_async`方法来向进程池中添加任务，这些任务将会在4个进程之间分配。最后我们关闭了进程池，并等待所有任务完成。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值