C进程池实现文件的传输

最新推荐文章于 2023-03-02 17:57:49 发布
最新推荐文章于 2023-03-02 17:57:49 发布
阅读量197 收藏 1
点赞数 1
文章标签： 多进程 c语言 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47178337/article/details/116430333
版权

工作流程图
在这里插入图片描述
头文件声明
prool.h

#include <stdio.h>
#include<sys/sendfile.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <dirent.h>
#include <time.h>
#include <pwd.h>
#include <grp.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/mman.h>
#include <sys/select.h>
#include <sys/time.h>
#include <pthread.h>
#include <setjmp.h>
#include <sys/time.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/msg.h>
#include <sys/uio.h>
#include <arpa/inet.h>
#include <sys/shm.h>
#include <sys/epoll.h>
#define ARGS_CHECK(argc, val) \
    if(argc != val) { \
        printf("error args\n"); \
        return -1; \
    } 


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

#define THREAD_ERROR_CHECK(ret, funcName) \
    do { \
        if (0 != ret) { \
            printf("%s : %s\n", funcName, strerror(ret)); \
        } \
    }while(0)


//父进程管理子进程的数据结构
typedef  struct {
    short flag;
    int pipefd;
    pid_t pid;
}process_data_t, *pProcess_data_t;
typedef  struct
{
    int len;
    char buf[1000];
}Train_t,*pTrain_t;
int makeChild(int processNum, pProcess_data_t pData);
int childFunc(int pipefd);
int tcpInit(char *ip, char *port, int *sockFd);
int epollAddFd(int fd, int epfd);
int sendFd(int pipeFd, int fd,char flag);
int recvFd(int pipeFd, int *fd,char *flag);

int recvCycle(int sockfd,void *buf,int totalLen);
int transFile(int clienFd);

TCP套接字初始化
tcpInit.c

#include "process_pool.h"

int tcpInit(char *ip, char *port, int *sockFd)
{
    int sfd = socket(AF_INET, SOCK_STREAM, 0);
    ERROR_CHECK(sfd, -1, "socket");

    struct sockaddr_in serAddr;
    memset(&serAddr, 0, sizeof(serAddr));
    serAddr.sin_family = AF_INET;
    serAddr.sin_addr.s_addr = inet_addr(ip);
    serAddr.sin_port = htons(atoi(port));

    //设置套接口地址可重用
    int reuse = 1; // 变量大于0，设置的选项生效
    setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));

    int ret = 0;
    ret = bind(sfd, (struct sockaddr*)&serAddr, sizeof(serAddr));
    ERROR_CHECK(ret, -1, "bind");

    ret = listen(sfd, 10);
    ERROR_CHECK(ret, -1, "listen");

    *sockFd = sfd;

    return 0;

}

主进程下，创建子进程，利用子进程创建进程池child.c

#include "process_pool.h"

int makeChild(int processNum, pProcess_data_t pData)
{
    int sfd[2];
    pid_t childPid = 0;
    for(int i = 0; i < processNum; ++i){
        socketpair(AF_LOCAL, SOCK_STREAM, 0, sfd);
        
        childPid = fork();
        if(0 == childPid){
            close(sfd[1]);
            childFunc(sfd[0]);
            exit(0);
        }

        close(sfd[0]);
        pData[i].flag = 0;
        pData[i].pid = childPid;
        pData[i].pipefd = sfd[1];
    }
    return 0;
}

int childFunc(int pipefd)
{
    int clienFd = 0;
    while(1){
        //接收父进程传来的newFd
        recvFd(pipefd, &clienFd,0);
        //写管道，使管道就绪，让父进程把自己的状态置为非忙碌的
        transFile(clienFd);        
        write(pipefd, "a", 1);
    }
    return 0;
}

epoll监听的封装epollAddFd.c

#include "process_pool.h"

int epollAddFd(int fd, int epfd)
{   
    struct epoll_event event;
    memset(&event, 0, sizeof(event));

    event.events = EPOLLIN;
    event.data.fd = fd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &event);

    return 0;
}

子进程下传递fd给进程池
sendFd

#include "process_pool.h"

int sendFd(int pipeFd, int fd)
{
    struct msghdr msg;
    memset(&msg, 0, sizeof(msg));

    struct iovec iov;
    memset(&iov, 0, sizeof(iov));
    char buf[8] = {0};
    strcpy(buf, "hi");

    iov.iov_base = buf;
    iov.iov_len = strlen(buf);

    msg.msg_iov = &iov;
    msg.msg_iovlen = 1;

    int len = CMSG_LEN(sizeof(int));
    struct cmsghdr *cmsg = (struct cmsghdr*)calloc(1, len);

    cmsg->cmsg_len = len;
    cmsg->cmsg_level = SOL_SOCKET;
    cmsg->cmsg_type = SCM_RIGHTS;

    *(int*)CMSG_DATA(cmsg) = fd;
    
    msg.msg_control = cmsg;
    msg.msg_controllen = len;

    sendmsg(pipeFd, &msg, 0);
    return 0;
}

进程池接收文件描述符和信息

#include "process_pool.h"

int recvFd(int pipeFd, int *fd)
{
    struct msghdr msg;
    memset(&msg, 0, sizeof(msg));

    struct iovec iov;
    memset(&iov, 0, sizeof(iov));
    char buf[8] = {0};
    strcpy(buf, "hi");

    iov.iov_base = buf;
    iov.iov_len = strlen(buf);

    msg.msg_iov = &iov;
    msg.msg_iovlen = 1;

    int len = CMSG_LEN(sizeof(int));
    struct cmsghdr *cmsg = (struct cmsghdr*)calloc(1, len);

    cmsg->cmsg_len = len;
    cmsg->cmsg_level = SOL_SOCKET;
    cmsg->cmsg_type = SCM_RIGHTS;
    
    msg.msg_control = cmsg;
    msg.msg_controllen = len;

    recvmsg(pipeFd, &msg, 0);
    *fd = *(int*)CMSG_DATA(cmsg);

    return 0;
}

进程池中的进程负责传输文件

#include "process_pool.h"

void sigfunc(int signum)
{
    printf("sig is comming\n");
}

int transFile(int clienFd)
{

    signal(SIGPIPE, sigfunc);
    //使用私有协议发送数据，人为的规定发送数据的边界
    Train_t train;
    memset(&train, 0, sizeof(train));
    int fd = open("file", O_RDWR);

    //存储文件名长度
    train.len = 4;
    strcpy(train.buf, "file");

    //发送文件名
    send(clienFd, &train, 4 + train.len, 0);


    while(1){
        int ret = read(fd, train.buf, sizeof(train.buf));
        train.len = ret;

        //send以一个已经断开的连接，会返回-1， 在次send的时候，会收到SIGPIPE信号
        //终止子进程
        int ret1 = send(clienFd, &train, 4 + train.len, 0);
        if(0 == ret){
            break;
        }
        if(-1 == ret1){
            printf("client exit\n");
            break;
        }

    }

    return 0;

}

主函数

#include "process_pool.h"
int pipe1[2];
void sigFunc(int sig)
{
    printf("sig \n");
    write(pipe1[1],&sig,4);
    //把、写入管道
}
int main(int argc, char** argv)
{
    //ip,port, processNum;
    int processNum = atoi(argv[3]);
    pProcess_data_t pData  = (pProcess_data_t)calloc(processNum,sizeof(process_data_t)); 
    makeChild(processNum,pData);
    //循环创建子进程
    pipe(pipe1);
    signal(SIGUSR1,sigFunc);
    
    int sfd;
    tcpInit(argv[1],argv[2],&sfd);
    //将sfd传出
    int epfd = epoll_create(1);

    epollAddFd(sfd,epfd);
    //将文件描述符纳入监听
    epollAddFd(pipe1[0],epfd);
    //把管道的读端纳入监听，如果是发送信号了，读端肯定就有数据了，证明来信号了

   
    for(int i = 0 ;i< processNum; i++)
    {
        //循环将管道的读端纳入监听
        epollAddFd(pData[i].pipefd,epfd);
    }
    int newfd;
    struct epoll_event evs[2];
    int num;
    while(1)
    {
        num = epoll_wait(epfd,evs,2,-1);
        for(int i = 0 ; i<num; i++)
        {
            if(evs[i].data.fd == sfd)
            {
                newfd = accept(sfd,NULL,NULL);
                for(int j = 0 ;j< processNum ; j++)
                {
                    if(pData[j].flag == 0)
                    {
                        sendFd(pData[j].pipefd, newfd,0);
                        break;
                    }
                }
                close(newfd);
            }
            if(evs[i].data.fd == pipe1[0])
            {
                //退出1，暴力
                /*
                for(int j=0 ;j<processNum; j++)
                {
                    kill(pData[j].pid,SIGUSR1);
                }
                */   
                for(int j=0 ;j<processNum; j++)
                {
                    //循环遍历所有子进程
                    sendFd(pData[i].pipefd,0,1);
                    //发送标志位1过去，证明要关闭了
                }
                for(int j = 0;j<processNum; j++)
                {
                    int s;
                    wait(&s);//捕获退出状态
                    if(WIFEXITED(s))
                    {
                        printf("num =%d \n",WEXITSTATUS(s));
                    }
               }
                    exit(0);//主进程也跟着完蛋了
            }
            else
            {

                for(int j = 0 ;j< processNum ; j++)
                {
                    if(pData[j].pipefd == evs[i].data.fd)
                    {
                        char buf[4] = {0};
                        read(pData[j].pipefd,buf,sizeof(buf));
                        pData[j].flag = 0;
                        break;
                    }
                }
            }
        }
    }
}
劝人学C
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c语言进程开发，创建与删除
05-21
一个进程管理的开发程序，可以对进程进行创建，删除，添加，等一此列功能，希望可以帮助大家
c语言实现的线程池
12-03
c语言线程池入门，根据需要添加自己的任务，支持一定数量的任务
c语言进程池原理及实现
jenie的专栏
05-31 1655
进程池与线程池出发点一样，都是考虑多核情况下任务的并行处理； 从多进程和多线程编程的区别上看，多线程有许多的同步、互斥的方法，较擅长于异步协作；而多进程同步、互斥的方法相对比较麻烦，则更多地考虑上下文独立执行； 从Nginx使用线程池/进程池处理大并发的思路去分析，其实就是多客户端大量连接的场景；主进程监听是否有新客户端tcp连接，然后分发给工作进程去响应http请求，在这种场景下每个连接都是一个独立的上下文逻辑，每个工作进程的内容都是对等地处理http请求，这种情况就非常适合进程池的方式； 把上述的.
内存池、进程池、线程池介绍及线程池C++实现
Enjoy Coding
09-16 6076
内存池 平常我们使用new、malloc在堆区申请一块内存，但由于每次申请的内存大小不一样就会产生很多内存碎片，造成不好管理与浪费的情况。 内存池则是在真正使用内存之前，先申请分配一定数量的、大小相等(一般情况下)的内存块留作备用。当有新的内存需求时，就从内存池中分出一部分内存块，若内存块不够再继续申请新的内存。这样做的一个显著优点是尽量避免了内存碎片，使得内存分配效率得到提升。
linux c语言 进程池实现,Linux下使用C实现线程池
weixin_36313293的博客
05-01 367
在高并发需求下，以往的方案(有事件发生时创建新线程处理事件，处理完后销毁线程)，这种方法由于创建线程和销毁线程浪费了大量的资源。因此转换一种思路，每次程序启动后先创建一些线程，让他们等事件发生，发生后再去处理，处理后不销毁，让他等待事件发生。今天用宇宙最强语言C语言来实现一下，先看一下线程池定义的结构体：structthreadpool_t{pthread_mutex_tlock;...
C语言实现简易网络进程及线程间通信
北回归线的博客
06-23 3557
1.单进程通信客户端代码#include<stdio.h> #include<arpa/inet.h> #include<sys/socket.h> #include<stdlib.h> #include<unistd.h> #include<strings.h> #include<netinet/in.h> #include<string.h> void usage(const char *str
c语言进程池的简单实现,C++线程池的简单实现方法
weixin_33235712的博客
05-22 641
本文以实例形式较为详细的讲述了C++线程池的简单实现方法。分享给大家供大家参考之用。具体方法如下：一、几个基本的线程函数：1.线程操纵函数：int pthread_create(pthread_t *tidp, const pthread_attr_t *attr, (void*)(*start_rtn)(void *), void *arg); //创建void pthread_exit(voi...
稍微研究一下就能看懂的进程池设计
IT说人话 的专栏
03-02 208
池 (Pool) 的概念被广泛地应用于软件开发领域，可以明显地提供应用的响应速度、改善效率、提供资源利用率。应用通过豢养一批空闲的 “工人”，”任务“来临时可以及时响应，避免了再次雇佣工人的消耗。此处的”工人“概念可以具体为进程（进程池）、线程（线程池）、连接（连接池）、内存（内存池）等。因为网络服务器在多进程模型下，是以操作系统申请资源为手段，以进程为载体来对外提供服务的。故，进程池是一种服务器后台提供服务或者网络功能的常见模型，主要目标是减少请求到来之时，才让操作系统创建进程进而对外提供服务的成本。
linux c语言 进程池实现,Linux线程池(C语言描述)
weixin_39952074的博客
05-01 185
创建线程或者进程的开销是很大的，为了防止频繁的创建线程，提高程序的运行效率，往往都会建立一个线程池用于多线程程序的调度下面的程序就是完整的线程池实现，主要采用互斥量和条件变量实现同步首先定义头文件threadpool.h在该文件中定义了线程池的数据结构和所有的函数#ifndef THREADPOOL_H_#define THREADPOOL_H_#include #include #include...
c半同步半异步进程池模型之cgi服务器
lkness的博客
09-17 1118
对半同步半异步进程池模型垂涎已久，这次中秋放假撸了下代码，代码写了几个模块，分别是： util：封装了套接字创建、unix族socket管道创建、中断信号、简单屏幕输出(可自行替换为日志文件输出) epoll_wrapper：封装了epoll相关操作包括创建epfd、添加epoll监听事件、删除epoll监听事件 myhshappool(我的半同步半异步进程池 - -!…)：封装了进程池初始化
linux c 进程池 简单实现
半坡居士
02-16 3941
进程池&amp;&amp;线程池 在面向对象程序编程中，对象的创建与析构都是一个较为复杂的过程，较费时间，所以为了提高程序的运行效率尽可能减少创建和销毁对象的次数，特别是一些很耗资源的对象创建和销毁。  所以我们可以创建一个进程池（线程池）,预先放一些进程（线程）进去,要用的时候就直接调用,用完之后再把进程归还给进程池,省下创建删除进程的时间,不过当然就需要额外的开销了。  利用线程池与进程池可以...
linuxC语言线程池实现CP命令
01-03
linux系统下C语言 利用线程池技术实现CP命令 压缩包包含：源代码+开发说明PPT 线程池头文件： //任务 struct task { void *(*task)(void *arg); void *arg; struct task *next; }; //线程池 typedef struct thread_pool { pthread_mutex_t lock;//互斥锁 pthread_cond_t cond;//条件变量 struct task *task_list;//任务队列 pthread_t *tids;//线程id unsigned waiting_tasks;//等待任务 unsigned active_threads;// bool shutdown;//停始状态 }thread_pool; //初始化线程池 bool init_pool(thread_pool *pool, unsigned int threads_number); //新增任务 bool add_task(thread_pool *pool, void *(*task)(void *arg), void *arg); //新增线程 int add_thread(thread_pool *pool, unsigned int additional_threads_number); //移除线程 int remove_thread(thread_pool *pool, unsigned int removing_threads_number); //销毁线程池 bool destroy_pool(thread_pool *pool); //处理程序 void *routine(void *arg);
C实现线程池
04-25
C实现线程池
JAVA上百实例源码以及开源项目
01-03
　Java局域网通信——飞鸽传书源代码，大家都知道VB版、VC版还有Delphi版的飞鸽传书软件，但是Java版的确实不多，因此这个Java文件传输实例不可错过，Java网络编程技能的提升很有帮助。 Java聊天程序，包括服务端和...
TCP/IP技术大全（中文PDF非扫描版）
08-12
2.3.2 文件传输协议 14 2.3.3 Telnet 14 2.3.4 Email 14 2.3.5 WWW 14 2.3.6 USENET News 15 2.4 Intranet和Extranet概览 15 2.4.1 Intranet 15 2.4.2 将Intranet对外开放 16 2.5 Internet的明天 16 2.5.1 下一代...
寒江独钓-Windows内核安全编程(高清完整版).part7
01-04
1.1.2 编写第一个C文件 3 1.1.3 编译一个工程 5 1.2 安装与运行 6 1.2.1 下载一个安装工具 6 1.2.2 运行与查看输出信息 7 1.2.3 在虚拟机中运行 9 1.3 调试内核模块 9 1.3.1 下载和安装WinDbg 9 1.3.2 设置Windows ...
JAVA上百实例源码以及开源项目源代码
12-11
Java数据压缩与传输实例 1个目标文件 摘要:Java源码,文件操作,数据压缩,文件传输 Java数据压缩与传输实例，可以学习一下实例化套按字、得到文件输入流、压缩输入流、文件输出流、实例化缓冲区、写入数据到文件、...
寒江独钓-Windows内核安全编程(高清完整版).part3
01-04
1.1.2 编写第一个C文件 3 1.1.3 编译一个工程 5 1.2 安装与运行 6 1.2.1 下载一个安装工具 6 1.2.2 运行与查看输出信息 7 1.2.3 在虚拟机中运行 9 1.3 调试内核模块 9 1.3.1 下载和安装WinDbg 9 1.3.2 设置Windows ...
线程池实现简单案例（C语言）
向往天空的鱼
09-07 1184
C语言简单实现线程池案例
用C语言实现一个简单的进程池
最新发布
05-27
好的，下面是一个使用C语言实现的简单进程池的示例代码： ```c #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/wait.h> #define MAX_PROCESSES 10 #define MAX_TASKS 20 typedef struct { void (*task)(void *); void *arg; } task_t; typedef struct { pid_t pid; int busy; int pipefd[2]; } worker_t; typedef struct { int count; worker_t workers[MAX_PROCESSES]; } process_pool_t; void worker_process(int pipefd[2]) { while (1) { task_t task; int n = read(pipefd[0], &task, sizeof(task)); if (n == 0) { break; } task.task(task.arg); } close(pipefd[0]); close(pipefd[1]); exit(0); } void process_pool_init(process_pool_t *pool) { pool->count = 0; } void process_pool_add_worker(process_pool_t *pool) { worker_t *worker = &pool->workers[pool->count++]; pipe(worker->pipefd); worker->pid = fork(); if (worker->pid == -1) { perror("fork"); exit(1); } else if (worker->pid == 0) { close(worker->pipefd[1]); worker_process(worker->pipefd); } else { close(worker->pipefd[0]); worker->busy = 0; } } void process_pool_submit_task(process_pool_t *pool, task_t task) { int i; for (i = 0; i < pool->count; i++) { if (!pool->workers[i].busy) { write(pool->workers[i].pipefd[1], &task, sizeof(task)); pool->workers[i].busy = 1; return; } } wait(NULL); process_pool_submit_task(pool, task); } void print_task(void *arg) { int *value = (int *)arg; printf("Task: %d\n", *value); sleep(1); } int main() { process_pool_t pool; process_pool_init(&pool); int i; for (i = 0; i < MAX_PROCESSES; i++) { process_pool_add_worker(&pool); } for (i = 0; i < MAX_TASKS; i++) { int *value = malloc(sizeof(int)); *value = i; task_t task = {print_task, value}; process_pool_submit_task(&pool, task); } for (i = 0; i < pool.count; i++) { write(pool.workers[i].pipefd[1], NULL, 0); } for (i = 0; i < pool.count; i++) { waitpid(pool.workers[i].pid, NULL, 0); } return 0; } ``` 在这个例子中，我们使用了一个进程池来管理多个工作进程，执行任务。每个工作进程都通过一个管道来接收任务，当有任务需要执行时，进程池会选择一个空闲的工作进程，将任务发送给它执行。当所有任务都执行完毕后，进程池会向每个工作进程发送一个空消息，通知它们退出。在主函数中，我们创建了20个任务，然后将它们提交给进程池来执行。在任务函数中，我们简单地打印出任务的编号并休眠一秒钟，模拟任务的执行过程。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值