网络编程——多进程服务器端

最新推荐文章于 2023-07-16 10:36:48 发布
最新推荐文章于 2023-07-16 10:36:48 发布
阅读量652 收藏 2
点赞数 1
分类专栏： 计算机网络 文章标签： 网络 服务器 socket tcp 多进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/beilizhang/article/details/121073023
版权

参考

  1. 《TCP/IP网络编程》

多进程服务器端

具有代表性的并发服务器端实现模型和方法：

  1. 多进程服务器：通过创建多个进程提供服务
  2. 多路复用服务器：通过捆绑并同一管理I/O对象提供服务
  3. 多线程服务器：通过生成与客户端等量的线程提供服务

多进程服务器不适合在Windows平台下

进程

进程的定义：占用内存空间的正在运行的程序。

进程ID

所有进程都会从操作系统分配到ID。此ID称为进程ID，其值为大于2的整数。1要分配给操作系统启动后的（用于协助操作系统）首个进程，因此用户进程无法得到ID值1

fork函数

fork函数将创建调用的进程副本。即并非完全不同的程序创建进程，而是复制正在运行的、调用fork函数的进程。另外，两个进程都将执行fork函数调用后的语句。但因为通过同一进程、复制相同的内存空间，之后的程序需要根据fork函数的返回值加以区分。即利用fork函数的如下特点区分程序执行流程：

  1. 父进程：fork函数返回子进程ID
  2. 子进程：fork函数返回0
#include <unistd.h>

pid_t fork(void);

成功时返回进程ID，失败时返回-1

示例
#include <stdio.h>
#include <unistd.h>

int gval = 0;
int main(int argc, char* argv[])
{
    pid_t pid;
    int lval = 20;
    gval++;
    lval++;

    pid = fork();
    if (pid == 0)                    // 子进程
    {
        gval += 2;
        lval += 2;
    }
    else                             // 父进程
    {
        gval -= 2;
        lval -= 2;
    }

    if (pid == 0)
    {
        printf("Child Proc: [%d, %d] \n", gval, lval);
    }
    else
    {
        printf("Parent Proc: [%d, %d] \n", gval, lval);
    }
    return 0;
}

僵尸进程

进程完成工作后（执行完main函数中的程序后）应被销毁，但有时这些进程将变成僵尸进程，占用系统中的重要资源。这种状态下的进程称作僵尸进程

产生僵尸进程的原因

调用fork函数产生子进程的终止方式：

  1. 传递参数并调用exit函数
  2. main函数中执行return语句并返回值

向exit函数传递的参数值和main函数的return语句返回的值都会传递给操作系统。而操作系统不会销毁子进程，直到把这些值传递给产生子进程的父进程。处在这种状态下的进程就是僵尸进程。所以要销毁僵尸进程，应该向创建子进程的父进程传递子进程的exit参数或return语句的返回值

但操作系统不会主动把这些值传递给父进程，只有父进程主动发起请求（函数调用）时，操作系统才会传递该值。而如果父进程未主动要求获得子进程的结束状态值，操作系统将一直保存，并让子进程长时间处于僵尸进程状态

创建僵尸进程示例
#include <stdio.h>
#include <unistd.h>

int main(int argc, char* argv[])
{
    pid_t pid = fork();

    if (pid == 0)                 // 子进程
    {
        puts("Hi, I am a child process");
    }
    else                          // 父进程
    {
        printf("Child Process ID: %d \n", pid);
        sleep(30);
    }

    if (pid == 0)
    {
        puts("End child process");
    }
    else
    {
        puts("End parent process");
    }
    return 0;
}
后台处理

后台处理是指将控制台窗口中的指令放到后台运行的方式。如果以如下方式运行上述示例，则程序将在后台运行（&将触发后台处理）：

root@my_linux:/tcpip# ./zombie &

如果采用这种方式运行程序，即可在同一控制台输入其他命令，无需另外打开新控制台

销毁僵尸进程方式1：利用wait函数
#include <sys/wait.h>

pid_t wait(int* statloc);

成功时返回终止的子进程ID，失败时返回-1

调用此函数时如果已有子进程终止，那么子进程终止时传递的返回值（exit函数的参数值，main函数的return返回值）将保存到该函数的参数所指内存空间。但函数参数指向的单元中还包含其他信息，因此需要通过下列宏进行分离：

  1. WIFEXITED：子进程正常终止时返回true
  2. WEXITSTATUS：返回子进程的返回值

所以，向wait函数传递变量status的地址时，调用wait函数后应编写：

if (WIFEXIED(status))              // 是否正常终止
{
    puts("Normal termination!");
    printf("Child pass num: %d", WEXITSTATUS(status));
}
wait函数示例
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main(int argc, char* argv[])
{
    int status;
    pid_t pid = fork();

    if (pid == 0)
    {
        return 3;
    }
    else
    {
        printf("Child PID: %d \n", pid);
        pid = fork();
        if (pid == 0)
        {
            exit(7);
        }
        else
        {
            printf("Child PID: %d \n", pid);
            wait(&status);
            if (WIFEXITED(status))
            {
                printf("Child send one: %d \n", WEXITSTATUS(status));
            }
            
            wait(&status);
            if (WIFEXITED(status))
            {
                printf("Child send two: %d \n", WEXITSTATUS(status));
            }
            sleep(30);
        }
    }
    return 0;
}

调用wait函数时，如果没有已终止的子进程，那么程序将阻塞（Blocking）直到有子进程终止，因此需谨慎调用该函数

销毁僵尸进程2：使用waitpid函数

调用waitpid函数时，程序不会阻塞

#include <sys/wait.h>

pid_t waitpid(pid_t pid, int* statloc, int options);

成功时返回终止的子进程ID（或0），失败时返回-1
（1）pid
等待终止的目标子进程的ID，若传递-1，则与wait函数相同，可以等待任意子进程终止

（2）statloc
与wait函数的statloc参数具有相同含义

（3）options
传递头文件sys/wait.h中声明的常量WNOHANG，即使没有终止的子进程也不会进入阻塞状态，而是返回0并退出函数

waitpid函数示例
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main(int argc, char* argv[])
{
    int status;
    pid_t pid = fork();

    if (pid == 0)
    {
        sleep(15);
        return 24;
    }
    else
    {
        while (!waitpid(-1, &status, WNOHANG))
        {
            sleep(3);
            puts("sleep 3sec.");
        }

        if (WIFEXITED(status))
        {
            printf("Child send %d \n", WEXITSTATUS(status));
        }
    }
    return 0;
}

信号与signal函数

父进程不能只调用waitpid函数以等待子进程终止，当子进程结束时通过操作系统通知父进程将更高效。于是引入信号处理（Signal Handling）机制。此处的“信号”是在特定事件发生时由操作系统向进程发生的消息

通过注册信号，当进程发现自己的子进程结束时，请求操作系统调用特定函数。这一功能可以通过signal函数实现，其在产生信号时调用，返回之前注册的函数指针

#include <signal.h>

void (*signal(int signo, void (*func)(int)))(int);

第一个参数为特殊情况信息，第二个参数为特殊情况下佳宁要调用的函数的地址值。发生第一个参数代表的情况时，调用第二个参数所指的函数

在signal函数中注册的部分特殊情况和对应常数：

  1. SIGALRM：已到通过调用alarm函数注册的时间
  2. SIGINT：输入CTRL+C
  3. SIGCHLD： 子进程终止

例如，完成“子进程终止则调用mychild函数”的请求：

signal(SIGCHLD, mychild);
signal函数示例
#include <stdio.h>
#include <unistd.h>
#include <signal.h>

void timeout(int sig)
{
    if (sig == SIGALRM)
    {
        puts("Time out!");
    }
    alarm(2);              // 实现每隔2秒重复产生SIGALRM信号
}
void keycontrol(int sig)
{
    if (sig == SIGINT)
    {
        puts("CTRL+C pressed");
    }
}

int main(int argc, char* argv[])
{
    int i;
    signal(SIGALRM, timeout);
    signal(SIGINT, keycontrol);
    alarm(2);             // 预约2秒后发送SIGALRM信号

    for (i = 0; i < 3; i++)
    {
        puts("wait...");
        sleep(100);
    }
    return 0;
}

其中，alarm函数的介绍如下：

#include <unistd.h>

unsigned int alarm(unsigned int senconds);

返回0或以秒为单位的距SIGALRM信号发生所剩时间。如果调用该函数的同时向它传递一个正整数参数，相应时间后将产生SIGALRM信号。若向该函数传递0，则之前对SIGALRM信号的预约将取消。如果通过该函数预约信号后未指定该信号对应的处理函数，则（通过调用signal函数）终止进程，不做任何处理

调用信号处理函数的主体的确是操作系统，但进程处于睡眠状态时无法调用函数。因此，产生信号时，为了调用信号处理器，将唤醒由于调用sleep函数而进入阻塞状态的进程，而且，进程一旦被唤醒就不会再进入睡眠状态。即使还未到sleep函数中规定的时间也是如此。所以，上述示例运行不到10秒就会结束

sigaction函数

sigaction函数类似于signal函数，而且完全可以代替后者，也更稳定，因为signal函数在UNIX系列的不同操作系统中可能存在区别，但sigaction函数完全相同

#include <signal.h>

int sigaction(int signo, const struct sigaction* act, struct sigaction* oldact);

成功时返回0，失败时返回-1
（1）signo
与signal函数相同，传递信号信息
（2）act
对应于第一个参数的信号处理函数（信号处理器）信息
（3）oldact
通过此参数获取之前注册的信号处理函数指针，若不需要则传递0

sigaction结构体定义如下：

struct sigaction
{
	void (*sa_handler)(int);
	sigset_t sa_mask;
	int sa_flags;
};

其中，sa_handler保存信号处理函数的指针值。sa_mask和sa_flags的所有位初始化为0即可，这两个成员用于指定信号相关的选项和特性

sigaction示例
#include <stdio.h>
#include <unistd.h>
#include <signal.h>

void timeout(int sig)
{
    if (sig == SIGALRM)
    {
        puts("Time out!");
    }
    alarm(2);
}

int main(int argc, char* argv[])
{
    int i;
    struct sigaction act;
    act.sa_handler = timeout;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGALRM, &act, 0);

    alarm(2);

    for (i = 0; i < 3; i++)
    {
        puts("wait...");
        sleep(100);
    }
    return 0;
}
利用sigaction消灭僵尸进程
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>

void read_childproc(int sig)
{
    int status;
    pid_t id = waitpid(-1, &status, WNOHANG);    // 调用waitpid函数，子进程将正常终止
    if (WIFEXITED(status))
    {
        printf("Remove proc id: %d \n", id);
        printf("Child send: %d \n", WEXITSTATUS(status));
    }
}

int main(int argc, char* argv[])
{
    pid_t pid;
    struct sigaction act;                        // 注册SIGCHLD信号对应的处理器
    act.sa_handler = read_childproc;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGCHLD, &act, 0);

    pid = fork();
    if (pid == 0)                                // 第一个子进程
    {
        puts("Hi! I'm child process");
        sleep(10);
        return 12;
    }
    else
    {
        printf("Child proc id: %d \n", pid);
        pid = fork();
        if (pid == 0)                            // 第二个子进程
        {
            puts("Hi! I'm child process");
            sleep(10);
            exit(24);
        }
        else                                     // 父进程
        {
            int i;
            printf("Child proc id: %d \n", pid);
            for (i = 0; i < 5; i++)
            {
                puts("wait...");
                sleep(5);
            }
        }
    }
    return 0;
}

基于多任务的并发服务器

扩展之前的回声服务器端，使其可以同时向多个客户端提供服务。每当有客户端请求服务时，回声服务器端都创建子进程以提供服务。为了完成这些任务，需要经过如下过程：

  1. 第一阶段：回声服务器端（父进程）通过调用accept函数受理连接请求
  2. 第二阶段：此时获取的套接字文件描述符创建并传递给子进程
  3. 第三阶段：子进程利用传递来的文件描述符提供服务
实现并发服务器
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define BUF_SIZE 30
void error_handling(char* message);
void read_childproc(int sig);

int main(int argc, char* argv[])
{
    int serv_sock, clnt_sock;
    struct sockaddr_in serv_adr, clnt_adr;

    pid_t pid;
    struct sigaction act;
    socklen_t adr_sz;
    int str_len, state;
    char buf[BUF_SIZE];
    if (argc != 2)
    {
        printf("Usage : %s <port>\n", argv[0]);
        exit(1);
    }

    act.sa_handler = read_childproc;            // 防止僵尸进程
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    state = sigaction(SIGCHLD, &act, 0);
    serv_sock = socket(PF_INET, SOCK_STREAM, 0);
    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family = AF_INET;
    serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_adr.sin_port = htons(atoi(argv[1]));

    if (bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr)) == -1)
    {
        error_handling("bind() error");
    }
    if (listen(serv_sock, 5) == -1)
    {
        error_handling("listen() error");
    }

    while (1)
    {
        adr_sz = sizeof(clnt_adr);
        clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_adr, &adr_sz);
        if (clnt_sock == -1)
        {
            continue;
        }
        else
        {
            puts("new client connected...");
        }
        pid = fork();
        if (pid == -1)
        {
            close(clnt_sock);
            continue;
        }
        if (pid == 0)                 // 子进程
        {
            close(serv_sock);         // 服务器端套接字文件描述符也传递到了子进程
            while ((str_len = read(clnt_sock, buf, BUF_SIZE)) != 0)
            {
                write(clnt_sock, buf, str_len);
            }
            
            close(clnt_sock);         // 子进程需要自己关闭复制过来的套接字
            puts("client disconnected...");
            return 0;
        }
        else
        {
            close(clnt_sock);
        }
    }
    close(serv_sock);
    return 0;
}

void read_childproc(int sig)
{
    pid_t pid;
    int status;
    pid = waitpid(-1, &status, WNOHANG);
    printf("removed proc id: %d \n", pid);
}

void error_handling(char* message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

注意：调用fork函数时复制父进程的所有资源。但套接字并非进程所有，从严格意义上说，套接字属于操作系统，只是进程拥有代表相应套接字的文件描述符。调用fork函数后，2个文件描述符指向同一套接字，只有2个文件描述符都终止（销毁）后，才能销毁套接字。因此，调用fork函数后，要将无关的套接字文件描述符关掉

分割TCP的I/O程序

对于已实现的回声客户端，传输数据后需要等待服务器端返回的数据，因为程序代码中重复调用了read和write函数。现在可以创建多个进程，分割数据的收发过程

客户端的父进程负责接收数据，额外创建子进程负责发送数据。分割后，不同进程分别负责输入和输出，这样，无论客户端是否从服务器端接收完数据都可以进程传输

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

#define BUF_SIZE 30
void error_handling(char* message);
void read_routine(int sock, char* buf);
void write_routine(int sock, char* buf);

int main(int argc, char* argv[])
{
    int sock;
    pid_t pid;
    char buf[BUF_SIZE];
    struct sockaddr_in serv_adr;
    if (argc != 3)
    {
        printf("Usage : %s <IP> <port>\n", argv[0]);
        exit(1);
    }

    sock = socket(PF_INET, SOCK_STREAM, 0);
    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family = AF_INET;
    serv_adr.sin_addr.s_addr = inet_addr(argv[1]);
    serv_adr.sin_port = htons(atoi(argv[2]));

    if (connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr)) == -1)
    {
        error_handling("connect() error!");
    }

    pid = fork();
    if (pid == 0)
    {
        write_routine(sock, buf);
    }
    else
    {
        read_routine(sock, buf);
    }

    close(sock);
    return 0;
}

void read_routine(int sock, char* buf)
{
    while (1)
    {
        int str_len = read(sock, buf, BUF_SIZE);
        if (str_len == 0)
        {
            return;
        }

        buf[str_len] = 0;
        printf("Message from server: %s", buf);
    }
}

void write_routine(int sock, char* buf)
{
    while (1)
    {
        fgets(buf, BUF_SIZE, stdin);
        if (!strcmp(buf, "q\n") || !strcmp(buf, "Q\n"))
        {
            shutdown(sock, SHUT_WR);             // 向服务器端传递EOF
            return;
        }
        write(sock, buf, strlen(buf));
    }
}

void error_handling(char* message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}
cqu_shuai
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python学习笔记(二十三) -- 多进程和多线程
苝花向暖丨楠枝向寒
09-02 917
目录 多线程多进程的意义 多进程的使用 方式一（fork）：  只能在Unix/Linux/Mac系统下执行，windows不可以 方式二（multiprocessing.Process）： 全平台通用 方式三(Pool)： 同时创建多个子进程 方式四(subprocess模块)： 进程间的通信 --Queue 多线程 简单使用 注意事项 Lock python其实不存在多...
基于Linux的网络编程——网络聊天程序
09-02
网络聊天程序是目前应用极为广泛的一种网络软件，对于方便人们的交流沟通非常有效，同时，... 程序基于Linux系统开发，纯C语言Socket实现多个客户端之间通信，由服务器端进行数据处理，基本实现聊天功能的基础运用。
【Linux网络编程】并发服务器之多进程模型
C/C++软件工程师、嵌入式软件工程师、物联网研发工程师、C/C++讲师、物联网讲师、嵌入式讲师---欢迎大家一起交流(私信添加博主微信)
07-29 778
00. 目录 文章目录00. 目录01. 概述02. 多进程并发服务器03. 多进程并发服务器实现思路04. 多进程并发服务器实现05. 附录 01. 概述 服务器设计技术有很多，按使用的协议来分有 TCP 服务器和 UDP 服务器，按处理方式来分有循环服务器和并发服务器。 循环服务器与并发服务器模型 在网络程序里面，一般来说都是许多客户对应一个服务器（多对一），为了处理客户的请求，对服务端的程序就提出了特殊的要求。 目前最常用的服务器模型 循环服务器：服务器在同一时刻只能响应一个客户端的请求。 并发服务
多进程服务器端
weixin_53344209的博客
03-16 511
之前打下了理论基础，现在才是开始学习构建实际服务器的知识。 0.1 进程概念及应用 利用之前学习到的内容，我们可以构建按序向第一个客户端到第一百个客户端提供服务的服务器端。当然，第一个客户端不会抱怨服务器端，但如果每个客户端的平均服务时间为0.5秒，则第100个客户端会对服务器端产生相当大的不满。 并发服务器端的实现方法 即使有可能延长服务时间，也有必要改进服务器端，使其同时向所有发起请求的客户端提供服务，以提高平均满意度。而且网络程序中数据通信时间比CPU运算时间占比更大，因此，向多个客户端提供服务是一种
十 多进程服务器端
weixin_48433164的博客
12-18 728
** 主要讲解多进程的具体实现 **： 10.1 进程概念以及应用 10.1.1 并发服务器端的实现方法 网络程序中 数据通信时间比CPU运算时间更多，因此，向多个客户端提供服务是一种有效利用CPU的方式 有几种具有代表性的并发服务器端的实现模型和方法： 1 多进程服务器端；通过创建多个进程提供服务 2 多路复用服务器：通过捆绑并统一管理I/O对象提供服务 3 通过生成与客户端等量的线程提供服务 本文主要是讲解第一种模型 10.1.2 进程：占用内存空间的正在运行的程序 CPU核个数和进程数目关系：核
linux网络编程-多进程实现TCP并发服务器
天道酬勤
02-23 2350
• socket函数创建监听套接字lfd • bind函数将监听套接字绑定ip和端口 • listen函数设置服务器为被动监听状态，同时创建一条未完成连接队列（没走完tcp三次握手流程的连接），和一条已完成连接队列（已完成tcp三次握手的连接） • accept函数循环的从已完成连接队列中提取连接，并返回一个新的套接字cfd跟客户端进行通信 • fork函数创建一个子进程，让子进程与客户端进行通信 • 子进程：read函数循环的从r缓冲区读取客户端发送的数据，write函数将要发送的数据写入w缓冲区
操作系统编程实验——创建进程.pdf
12-22
操作系统编程实验——创建进程 ...操作系统编程有广泛的应用前景，如操作系统的开发和维护、嵌入式系统的开发、服务器端编程等。掌握操作系统编程的基本技能和技术，对于学生的职业发展和技术创新具有重要意义。
C语言网络编程——课程设计文档
03-21
《C语言网络编程——课程设计文档》 C语言网络编程是一种基础且强大的技术，它使得开发者可以直接操作底层网络协议，实现高效、灵活的网络应用程序。本课程设计文档旨在引导学生深入理解网络编程的基本原理，通过...
网络编程——进程 （包括整个项目和代码，可以运行）
12-28
本项目专注于“网络编程——进程”，提供了一个完整的项目和可运行的代码，主要涉及C#语言，旨在帮助开发者深入理解如何在多进程环境下进行网络通信。 1. **进程概念**： - 进程是操作系统中的一个实体，代表一个...
TCP/IP网络编程(8) 基于Linux的多进程服务器
开到荼蘼的博客
07-30 716
接着服务端接收到客户端发送来的的EOF，并将其返回给客户端(此时客户端的接收功能并未关闭，还能正常接收服务端的EOF)，客户端在判断接收到服务端发送来的EOF之后，结束接收流程，也同样调用main中后续的代码，执行close和return，此时客户端的socket又被关闭了一次，至此，客户端中的socket被成功关闭，子进程和父进程都结束。fork函数创建的是调用它的进程的副本，即它是复制正在运行的，调用fork函数的进程，此外，在fork()函数返回后，两个进程都将执行fork()函数后面的语句。....
Linux网络编程基础＜多进程并发服务器＞
Lee1989
09-17 503
所以只需要在fork创建的子线程里面处理与客户端的数据通信，在父进程处理连接客户端的数量处理，也就是回收进程资源。服务器端的程序是俩个套接字socket创建一个lfd，accept创建一个cfd阻塞连接套接字。
【TCP/IP】多进程服务器的实现(进阶) - 进程的概念及fork函数
Tsang的博客
06-08 899
进程（Process）是计算机中程序关于某数据集合上的一次运行活动，是系统进行资源分配的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
C++网络编程踩坑记之多进程服务器，详解代码细节，多问为什么
踩坑博客
05-25 511
  首先介绍多进程并发服务器是什么，然后按步骤描述怎么用，在最后给出完整server.c的代码，wrap.c错误处理代码，和client.c的代码。希望大佬多交流，敬请斧正。 是什么： 提示：这节是多进程并发服务器，其实现原理是，服务端通过lfd负责监听客户端的连接。当接受到一个客户端的连接时，建立一个子进程通过cfd与客户端进行数据通信，那么这个服务端就可以响应多个客户端。涉及到的是信号，多进程的相关知识。 服务器按处理方式可以分为迭代服务器和并发服务器两类。 迭代服务器：服务器每次只能处理一个客户的请
一文了解如何在window上轻松实现多进程任务
algorithm learning blog
08-29 2314
参考 苏神写的parallel_apply link python中multiprocessing文档 link 前言 在之前的工作中，我经常使用的多进程方式是进程池，在看了苏神写的parallel_apply之后，发现多进程使用队列的方式运行，从显示上（tqdm显示运行程度），灵活性上都更加好，但是运行时发现多进程在windows的支持上很不友好，于是打算写一篇在windows上容易使用的多进程方法，当然也可以在linux上使用。 使用多进程来提高程序的运行效率是非常重要的，通常可以在数据处理，矩阵运算等
【TCP/IP】多进程服务器的实现(进阶) - 多进程服务器模型及代码实现
Tsang的博客
06-12 2754
经过前面的铺垫，我们已经具备实现并发服务器的基础了，接下来让我们尝试将之前的单任务回声服务器改装成多任务并发模式
多进程并发服务器
laugh哥的博客
11-28 741
最核心的就是：多进程实现客户端，然后把出错处理函数模块化
并发服务器 - 多进程服务器
weixin_45684629的博客
12-04 672
通过多进程服务器来实现并发服务器、客户端读写功能分割到进程
TCP/IP网络编程 第十章:多进程服务器端
最新发布
Reol99999的博客
07-16 1130
简要的介绍了一下多进程服务器

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值