进程池

最新推荐文章于 2021-12-29 19:45:10 发布
最新推荐文章于 2021-12-29 19:45:10 发布
阅读量210 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zbh_pro/article/details/72851806
版权

进程池应用至少包括两部分

   资源进程：预先创建好的空闲进程，管理进程会把工作分给空闲进程来处理

   管理进程：管理进程负责创建资源进程，把工作分给空闲资源进程，回收已经完成工作的资源进程。

进程池的实现

      让服务器在启动阶段调用fork创建一个子进程池，通过子进程来处理客户端请求。子进程与父进程之间使用socketpair进行通信（为了方便使用sendmsg与recvmsg，如果使用匿名管道，则无法使用以上两个函数）。以下针对TCP进行分析.

     server端使用select轮询用于监听客户端请求的被动套接字fd_listen以及用于父子之间通信的socketpair。每当客户端有请求时，server端会将由accept返回的用于与客户端通信的socket描述符通过socketpair发送给一个空闲的子进程，由子进程与客户端进行通信（处理请求）。因此服务器端需要维护一个子进程队列，队列中的每个元素存放着与子进程通信的socketpair以及标记子进程是否空闲的标志位，如下：

Tyepdef  struct  tag_chd

{

int s_sfd;      //与子进程通信的socketpair描述符

Int s_state;    //标记子进程是否空闲

}NODE, *pNODE;

每当子进程处理完客户端请求时，会通过socketpair向server端发送消息，server端select到该socketpair后，会将对应子进程标志位设置为空闲。

注意

1. 由于父进程是先创建子进程，之后才accept用于与客户端通信的socket描述符fd_client，因此子进程的pcb中并没有fd_client的信息。server端需要将fd_client发送子进程。如果只是用send来发送fd_client信息的话，子进程只会将其当成一个整型数。我们需要用sendmsg将fd_client连同其辅助(控制)信息一并发送，这样子进程才会将其当成一个socket描述符。

2. 父进程预先创建子进程池，该子进程如同server端一样是永远不会退出的。子进程中使用while死循环，如下：

while(1){

     readn = read(sfd, &flag, 4);       // 服务器分配的子进程在子进程队列中的下标

     printf("readn: %d \n", readn);             

     printf("read from father: %d \n", flag);

     recv_fd(sfd, &fd_client);  // recv_fd中封装了recvmsg，接收与客户端通信的socket

//描述符

     handle_request(fd_client);                  // 处理客户端请求

     write(sfd, &pid, sizeof(pid));  // 处理完请求后通过socketpair通知服务器，服务器

                              //将该子进程设置为空闲

    }

每当子进程处理完一个客户端请求后（也就是客户端退出了），子进程会阻塞在 read 处，等待接收下一个客户端请求。

由于是while死循环，且死循环中没有break语句，因此子进程不可能跳出这个while循环，也就不会执行while循环以下的内容了，这样可以保证子进程结尾没有exit也不会执行之后的内容。

 

 

 

代码实现：

Server.h

#ifndef __SERVER_H__

#define __SERVER_H__

#include "my_socket.h"

#include <sys/stat.h>

#include <sys/types.h>

#include <fcntl.h>

#include <sys/time.h>

#include <sys/select.h>

#include <sys/uio.h>

#include <sys/wait.h>

#include <errno.h>

#define SER_IP "127.0.0.1"

#define SER_PORT 8888

#define ST_BUSY 1

#define ST_IDLE 2

#define SIZE 8192

#define MSG_SIZE (SIZE - 4)

 

typedef struct tag_mag

{

    int msg_len ;

    char msg_buf[MSG_SIZE];//8188

}MSG, *pMSG;

 

typedef struct tag_chd

{

    int s_sfd ;

    int s_state ;

}NODE, *pNODE;

 

extern int errno ;

void make_child(pNODE arr, int cnt);

void child_main(int sfd) ;

void handle_request(int sfd);

void send_fd(int sfd, int fd_file) ;

void recv_fd(int sfd, int* fd_file) ;

void dispatch(pNODE arr, int cnt, int fd_client);

#endif

 

 

Server.c

#include "server.h"

void make_child(pNODE arr, int cnt)

{

    int index ;

    for(index = 0; index < cnt; index ++)

    {

        pid_t pid ;

        int fds[2] ;//fds[0] - c  fds[1] - p

        socketpair(AF_LOCAL, SOCK_STREAM, 0, fds);

        pid = fork() ;

        if(pid == 0)// child

        {

            close(fds[1]);         /* 子进程用fds[0]，关闭fds[1] */

            child_main(fds[0]) ;   /* 每创建一个子进程，子进程就进入该函数中(死循环),接收请求，处理请求，如此循环。*/

 

        }else

        {

            /* 初始化进程池队列中的每一个子进程 */

            arr[index].s_sfd = fds[1] ;

            arr[index].s_state = ST_IDLE ;

            close(fds[0]);         /* 父进程用fds[1], 关闭fds[0] */

        }

 

    }

 

}

void child_main(int sfd)

{

    int fd_client ;

    int flag ;

    int readn ;

    pid_t pid = getpid();

    while(1)

    {

        readn = read(sfd, &flag, 4);

        printf("readn: %d \n", readn);

        printf("read from father: %d \n", flag);

        recv_fd(sfd, &fd_client);//从父进程中读出客户端的描述符

        handle_request(fd_client);

        write(sfd, &pid, sizeof(pid));

    }

}

void handle_request(int sfd)

{    

 

    MSG my_msg ;

    int recvn ;

    while(1)

    {

        memset(&my_msg, 0, sizeof(MSG));

        my_recv(&recvn, sfd, &my_msg, 4);

        if(my_msg.msg_len  == 0)//如果客户端退出

        {

            break ;

        }

        my_recv(NULL, sfd, my_msg.msg_buf, my_msg.msg_len);

        my_send(NULL, sfd, &my_msg, my_msg.msg_len + 4);

 

    }

 

}
//父进程传文件描述符给子进程

void send_fd(int sfd, int fd_file)

{

    struct msghdr my_msg ;

    memset(&my_msg, 0, sizeof(my_msg));

    

    struct iovec bufs[1] ;

    char buf[32] = "hello world ! \n";

    bufs[0].iov_base = buf ;

    bufs[0].iov_len = strlen(buf) ;

    

    my_msg.msg_name = NULL ;

    my_msg.msg_namelen = 0 ;

    my_msg.msg_iov = bufs ;

    my_msg.msg_iovlen = 1 ;

    my_msg.msg_flags = 0 ;

 

    struct cmsghdr *p  ;

    int cmsg_len = CMSG_LEN(sizeof(int)) ;     /* 所传为文件描述符，因此sizeof(int) */

    p = (struct cmsghdr*)calloc(1, cmsg_len) ;

    p -> cmsg_len = cmsg_len ;

    p -> cmsg_level = SOL_SOCKET ;

    p -> cmsg_type = SCM_RIGHTS ;

    *(int*)CMSG_DATA(p) = fd_file ;

    

    my_msg.msg_control = p ;

    my_msg.msg_controllen = cmsg_len ;

    

    int sendn ;

    sendn = sendmsg(sfd, &my_msg, 0);

    printf("send masg len : %d \n", sendn);

}

void recv_fd(int sfd, int* fd_file)

{

    struct msghdr my_msg ;

    

    struct iovec bufs[1] ;

    char buf1[32]="" ;

    bufs[0].iov_base = buf1 ;

    bufs[0].iov_len = 31 ;

 

    my_msg.msg_name = NULL ;

    my_msg.msg_namelen = 0 ;

    my_msg.msg_iov = bufs ;

    my_msg.msg_iovlen = 2 ;

    my_msg.msg_flags = 0 ;

    

    struct cmsghdr *p  ;

    int cmsg_len = CMSG_LEN(sizeof(int)) ;

    p = (struct cmsghdr*)calloc(1, cmsg_len) ;

    my_msg.msg_control = p ;

    my_msg.msg_controllen = cmsg_len ;

    

    int recvn ;

    recvn = recvmsg(sfd, &my_msg, 0);

    

    *fd_file = *(int*)CMSG_DATA((struct cmsghdr*)my_msg.msg_control); //写成

                              //*(int*)CMSG_DATA(P)也可

    printf("buf1: %s, recv msg len : %d   \n", buf1, recvn);

 

}

void dispatch(pNODE arr, int cnt, int fd_client)

{

    int index ;

    for(index = 0 ; index < cnt; index ++)

    {

        if(arr[index].s_state == ST_IDLE)

        {

            write(arr[index].s_sfd, &index, 4);

            send_fd(arr[index].s_sfd, fd_client); /* 向空闲的子进程分配任务，将服务器

accept返回的socket描述符发送给子进程*/

            arr[index].s_state = ST_BUSY ;

            break ;

        }

    }

}

 

client.c

#include "my_socket.h"

#define MY_IP "127.0.0.1"

#define MY_PORT 6666

#define SER_IP "127.0.0.1"

#define SER_PORT 8888

#define SIZE 8192

#define MSG_SIZE (SIZE - 4)

typedef struct tag_mag//

{

    int msg_len ;

    char msg_buf[MSG_SIZE];//8188

}MSG, *pMSG;

int main(int argc, char* argv[])

{

    int sfd ;

    my_socket(&sfd, MY_TCP, MY_IP, atoi(argv[1]));

    my_connect(sfd, SER_IP, SER_PORT);

    MSG my_msg ;

    while(memset(&my_msg, 0, sizeof(MSG)), fgets(my_msg.msg_buf, MSG_SIZE, stdin)!= NULL)

    {

        my_msg.msg_len = strlen(my_msg.msg_buf);

        my_send(NULL, sfd, &my_msg, 4 + my_msg.msg_len );

        memset(&my_msg, 0, sizeof(MSG));

        my_recv(NULL, sfd, &my_msg, 4);

        my_recv(NULL, sfd, &my_msg.msg_buf, my_msg.msg_len);

        printf("recv from server : %s \n", my_msg.msg_buf);

    

    }

    /* 客户端退出时，向服务器发送一个长度为0的消息 ，用于通知服务器退出 */

    memset(&my_msg, 0, sizeof(MSG));

    my_send(NULL, sfd, &my_msg, 4 + my_msg.msg_len);

    close(sfd);

 

}

main.c

 

#include "server.h"

int main(int argc, char* argv[])//exe chld_cnt

{

    if(argc != 2)

    {

        printf("Usage: exe , child_cnt! \n");

        exit(1);

    }

    int child_cnt = atoi(argv[1]);

    pNODE arr_child = (pNODE)calloc(child_cnt, sizeof(NODE)) ; /* 动态数组维护子进程池 */

    make_child(arr_child, child_cnt);

    

    int fd_listen, fd_client ;

    my_socket(&fd_listen, MY_TCP, SER_IP, SER_PORT);

    my_listen(fd_listen, 10);

    

    fd_set readset, readyset ;

    FD_ZERO(&readset);

    FD_ZERO(&readyset);

    FD_SET(fd_listen, &readset);//先将监听客户端的描述符设置到监听集合

    int index ;

    for(index = 0; index < child_cnt; index ++)

    {

        FD_SET(arr_child[index].s_sfd, &readset);//再将和子进程的通信的socket设置到监听集合

    }

    

    int select_ret ;

    struct timeval tm ;

    while(1)

    {

        tm.tv_sec = 0 ;

        tm.tv_usec = 1000 ;

        readyset = readset ;

        select_ret = select(1024, &readyset, NULL, NULL, &tm);

        if(select_ret == 0)        /* 轮询时间内，所有描述符均没有活动，返回0，继续轮询 */

        {

            continue ;

        }else if(select_ret == -1) /* 信号 */

        {

            if(errno == EINTR)

            {

                continue ;

            }else

            {

                exit(1);

            }

        }else

        {

            if(FD_ISSET(fd_listen, &readyset))//如果是客户端发来的信号

            {

            fd_client = accept(fd_listen, NULL, NULL) ;    

            dispatch(arr_child, child_cnt ,fd_client);

            close(fd_client);

            }

            for(index = 0; index < child_cnt; index ++)

            {

                if(FD_ISSET(arr_child[index].s_sfd, &readyset))//是子进程发来的信号

                {

                    int val ;

                    read(arr_child[index].s_sfd, &val, 4);

                    arr_child[index].s_state = ST_IDLE ;

                }

            }

            

        }

        

    }   

}

 

 

zbh_pro
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
mysql socket文件作用详解
12-16
网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket，一般在配置部署mysql环境时都会在mysql的my.cnf文件中[mysqld]栈下添加上socket文件的路径，而这样做的好处是如果启用了多实例mysql时，可以通过socket文件来快速的登录mysql对应不同端口下的实例，如在一台有部署2个实例的mysql服务一个是用3306，一个是用3307端口，那么就可以通过2个不同的socket文件快速的登录 mysql -uroot -p –socket=/tmp/mysql3307.sock –port=3307 #当然这里不指定端口也是可以的 当然平
Lunix网络编程之socket（客户端发送请求，服务器处理例如：排序，两人联机五子棋）
代码随想录
09-03 1448
使用时可以将my_socket.h 和my_socket.c封装成库 封装库的方法在linux学习 建立静态库，动态库，写简单的makefile http://blog.csdn.net/youngyangyang04/article/details/38616463 或者编译的时候直接gcc .c -o .exe -I ./ 就是编译的时候直接把my_socket.h 和my_socket.c加进去
mysql socket 作用
纤手小白
07-15 4154
mysql.sock是mysql的主机和客户机在同一host上的时候，使用unix domain socket做为通讯协议的载体，它比tcp快。 Mysql有两种连接方式： （1）TCP/IP （2）socket 对mysql.sock来说，其作用是程序与mysqlserver处于同一台机器，发起本地连接时可用。 例如你无须定义连接host的具体IP得，只要为空或localhos...
Python使用socket模块实现简单tcp通信
菜鸟教程
11-28 421
更多编程教程请到：菜鸟教程 https://www.piaodoo.com/ 友情链接： 高州阳光论坛https://www.hnthzk.com/ 正文开始： 服务器端代码： # 再来简单的测试，这个是服务器端 import socket import sys BUF_SIZE = 1024 ip_port = (r"127.0.0.1", 11552) my_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 先拿到套接
MySocket服务器与客户端的相互响应
Story__struggle的博客
08-14 1359
在Java中的编写服务器端的程序时，服务器在接收到客户端发来的连接请求时，将一些信息传递给客户端，同样的客户端同时可以将一些信息打包发送到服务器端显示出来 下面是编写的程序 服务器端：public class MySocketServer {//服务器器端 public static void main(String[] args) { try { ServerSocket ser
Python多进程multiprocessing、进程池用法实例分析
09-17
主要介绍了Python多进程multiprocessing、进程池用法,结合实例形式分析了Python多进程multiprocessing、进程池相关概念、原理、用法及操作注意事项,需要的朋友可以参考下
python多进程（加入进程池）操作常见案例
09-18
主要介绍了python多进程（加入进程池）操作,结合常见案例形式分析了Python多进程复制文件、加入进程池及多进程聊天等相关操作技巧,需要的朋友可以参考下
Python中的自定义进程和进程池
12-20
Python中的自定义进程和进程池 文章目录Python中的自定义进程和进程池一、自定义进程1.步骤：2.例进程池1.概念2.介绍——multiprocess.Pool3.非阻塞式进程池4.阻塞式进程池5.例 一、自定义进程 1.步骤： 继承python...
Python 多进程并发操作中进程池Pool的实例
09-21
下面小编就为大家带来一篇Python 多进程并发操作中进程池Pool的实例。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Linux进程池.zip
08-12
Linux C开发的Linux进程池。 Linux C开发的Linux进程池。 Linux C开发的Linux进程池。 Linux C开发的Linux进程池。
mysocket
古德湖的福禄
06-04 665
client package com.sun.mysocket; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.PrintWriter; import java.ne...
socket连接池之MySocket重写close问题
cszeus的专栏
12-25 413
MySocket是一个继承Socket的类，重写了close方法（网上这类代码很多）。有一点要注意，当关闭MySocket对象的输入输出流时，会调用其中的close（）方法！
VC使用MYSQL数据库出现my_socket fd未定义错误处理
ahcpx的专栏
11-02 2586
<br />错误提示：错误 1 error C2146: 语法错误 : 缺少“;”(在标识符“fd”的前面) <br />这个错误是在VC中使用MYSQL数据库时出现在mysql_com.h文件中的  my_socket fd; 说明未my_socket未定义，这时只需要在引用mysql.h头文件之前引用#include <winsock2.h>就行了，有的上面说引用#include <window.h>是错误的
TCP通信Socket编程----传输不同数据类型。
Abner's Technology Blog
12-29 2036
更新记录】：2021.12.29、 TCP通信传输字符串和浮点数。 作业题目说明：“实现基于TCP的socket通信，完成字符串、浮点数据的传输。” mine_：我之前是想直接将用户输入的传过去就行了，但这样其实就是字符串形式传输了。而题目希望我们分别传输字符串和浮点数这两种格式，最终在网络中都是以字节形式传输，但是对于数据处理的方法不同。还有一个核心考察点就是需要思考粘包问题，即需要运用封包技术。python中一个浮点数的字节是4个字节，是固定的。而字符串的字节就不固定了。 mine_下次改进】：还有哪些
解决Windows下连接Mysql出现 unknown type name 'SOCKET' my_socket fd;
zsy135220的博客
05-10 2470
解决这样的问题很简单，只需要将#include &lt;winsock.h&gt; 包含在#include &lt;mysql.h&gt;的前面就可以了或者在mysql_com.h 添加#ifndef my_socket_defined #if defined(__WIN32__) &amp;&amp; !defined(__WIN__) #define my_socket SOCKET #el...
关于mysocket类的更新
sx1989827的专栏
01-31 1875
<br />       这两天写一个远程控制的程序，在本机上测试没问题，但是换成远程测试的时候，许多问题就来了，这才发现不是简单的send和recv就可以了事的，实际的网络通信很复杂，数据不是一次发送和接受就可以成功的，所以要做判断，然后循环发送和接受。<br />mysock
clib_mysql.h,在C++中包含mysql.h头文件，编译时却找不到my_socket类型，是咋回事啊...
weixin_34271294的博客
03-12 184
当前位置:我的异常网» C++»在C++中包含mysql.h头文件，编译时却找不到my_socke在C++中包含mysql.h头文件，编译时却找不到my_socket类型，是咋回事啊www.myexceptions.net网友分享于：2013-04-13浏览：231次在C++中包含mysql.h头文件，编译时却找不到my_socket类型，是怎么回事啊?已经在项目属性中加入了头文件和D...
7.18 进程池方式的 socket
aocaiti5781的博客
07-18 89
2018-7-18 22:05:28 笔记都做完了 睡觉睡觉!!!明天早起!发现python慢慢深入变得很强大,很好玩!!! 进程池版本的socket 更加优化了,比多进程版本的效率更高 seerver端 # !/usr/bin/env python # !--*--coding:utf-8 --*-- # !@Time :2018/7/18 20:50 # !@...
python 进程池
最新发布
05-31
Python 的进程池是一种用于并发处理任务的机制。它可以在同一时间内处理多个进程，提高程序的执行效率。Python 的 multiprocessing 模块提供了进程池的实现，使用起来非常方便。 以下是一个简单的 Python 进程池的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值