TCP多进程并发服务器与多进程客户端实验

于 2023-02-23 15:47:23 发布
阅读量206 收藏
点赞数
文章标签： tcp/ip 服务器 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51430625/article/details/129183297
版权

2022年版
tcp_echo_cli.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>

#define MAX_CMD_STR 100
#define bprintf(fp, format, ...) \
    if(fp == NULL){printf(format, ##__VA_ARGS__);}  \
    else{printf(format, ##__VA_ARGS__); \
            fprintf(fp, format, ##__VA_ARGS__);fflush(fp);}

int sig_type = 0;
FILE * fp_res = NULL;//文件指针

void sig_pipe(int signo) {
    sig_type = signo;
    return;
}
int  sig_chld_id = 0;
void sig_chld(int signo){
    int pid_chld;
    while((pid_chld = waitpid(-1, NULL, WNOHANG) > 0)){
        printf("[srv](%d) server child(%d) terminated.\n", getpid(), pid_chld);
    };
    return;
}
void sig_int(int signo){
    exit(0);
    return;
}

int echo_rqt(int sockfd, int pin, FILE *fp_res){
    FILE *file_td;
    char  file_name_td[50];
    const int pin_h = pin;
    const int pin_n = htonl(pin);
    char dat[MAX_CMD_STR];
    int len_h = 0;
    int len_n = 0;
    int len_rev_h = 0;
    int len_rev_n = 0;
    char  buf[MAX_CMD_STR + 9];
    sprintf(file_name_td, "td%d.txt", pin);
    file_td = fopen(file_name_td, "r");
    if(file_td == 0){
        fprintf(fp_res, "[cli](%d) Test data read error!\n", pin_h);
        printf("[cli](%d) Test data read error!\n", pin_h);
        exit(0);
    }
    
    char* temp;
    while((temp = fgets(buf, MAX_CMD_STR, file_td))){
        len_h = strlen(buf);
        len_n = htonl(len_h);
        if(strncmp(buf, "exit", 4) == 0){
            fclose(file_td);
            return 0;
        }
        int i = 0;                
        while(buf[i] != '\n'){     
            i++;
        }
        if(buf[i] == '\n'){
            buf[i] = '\0';
        }
        if(send(sockfd, &pin_n, 4, 0) == -1){
            printf("editor: send data error pin, errno:%d!\n", errno);
        }
        if(send(sockfd, &len_n, 4, 0) == -1){
            printf("editor: send data error len!\n");
        }
        if(send(sockfd, buf, len_h, 0) == -1){
            printf("editor: send data error buf!\n");
        }
        memset(buf, 0, MAX_CMD_STR);
        int tmp_pin_rev = 0;
        recv(sockfd, &tmp_pin_rev, 4, 0);
        if(recv(sockfd, &len_rev_n, 4, 0) == -1){
            printf("editor: some error happened! in 108 num: %d\n", pin);
            return 0;
        };
        len_rev_h = ntohl(len_rev_n);
        int count = 0;
        int tmp_len_rev = 0;
        
        count = 0;
        while(count < len_rev_h){
            if((tmp_len_rev = recv(sockfd, buf + count, len_rev_h - count, 0)) == -1){
                printf("editor: some error happened!\n");
                return 0;
            }
            if(tmp_len_rev == 0){
                printf("editor: not data\n");
                break;
            }
            count += tmp_len_rev;
        }
        fprintf(fp_res, "[echo_rep](%d) %s\n", getpid(), buf);
    }
    fclose(fp_res);
    return 0;
}
int main(int argc, char* argv[])
{
    
    if(argc != 4){
        printf("Usage:%s <IP> <PORT> <CONCURRENT AMOUNT>\n", argv[0]);
        return 0;
    }

    struct sigaction sigact_pipe,sigact_pipe_old;
    sigact_pipe.sa_handler = sig_pipe;//sig_pipe()，信号处理函数
    sigemptyset(&sigact_pipe.sa_mask);
    sigact_pipe.sa_flags = 0;
    sigact_pipe.sa_flags |= SA_RESTART;//设置受影响的慢系统调用重启
    sigaction(SIGPIPE, &sigact_pipe, &sigact_pipe_old);
    
    struct sigaction sigact_chld, sigact_chld_old;
    sigact_chld.sa_handler = sig_chld;
    sigemptyset(&sigact_pipe.sa_mask);
    sigact_pipe.sa_flags |= SA_RESTART;
    sigaction(SIGCHLD, &sigact_chld, &sigact_chld_old);


    struct sockaddr_in  srv_addr;
    struct sockaddr_in  cli_addr;
    socklen_t  cli_addr_len;
    memset(&srv_addr, 0, sizeof(srv_addr));
    srv_addr.sin_family = AF_INET;
    inet_pton(AF_INET, argv[1], &srv_addr.sin_addr);
    srv_addr.sin_port = htons(atoi(argv[2]));
    int  connfd;
    char  av3[10];
    strncpy(av3, argv[3], 5);
    int conc_amnt = atoi(av3);
    
    int i = 0;
    while (i < conc_amnt - 1) {
        if (!fork()) {
            char  file_name_cli[50];
            sprintf(file_name_cli, "stu_cli_res_%d.txt", i+1);
            
            FILE * fp_res;
            fp_res = fopen(file_name_cli, "ab"); 
            if(!fp_res){
                printf("[cli](%d) child exits, failed to open file \"stu_cli_res_%d.txt\"!\n", getpid(), i+1);
                exit(-1);
            }

            printf("[cli](%d) stu_cli_res_%d.txt is created!\n", getpid(), i+1);
            fprintf(fp_res, "[cli](%d) child process %d is created!\n", getpid(), i+1);

            int clientfd;
            if((clientfd = socket(PF_INET, SOCK_STREAM, 0)) == -1){
                printf("editor: create socket error in child process %d, exit...\n", getpid());
                exit(0);
            }
            while(1){
                int  con_res;
                
                con_res = connect(clientfd, (struct sockaddr *)(&srv_addr), sizeof(srv_addr));
                if(con_res == 0){
                    fprintf(fp_res, "[cli](%d) server[%s:%s] is connected!\n", getpid(), argv[1], argv[2]);
                    char  ip_str[50];
                    if(echo_rqt(clientfd, i+1, fp_res) == 0){
                        close(clientfd);
                        break;
                    }
                    else{
                        printf("editor: some error happened in echo_rqt, in child_process :%d\n",getpid());
                        fclose(fp_res);
                        exit(0);
                    }
                }
                else{
                    if(sig_chld_id){
                        printf("editor: int happened\n");
                    }
                    fclose(fp_res);
                    exit(0);
                }
            }
            fprintf(fp_res, "[cli](%d) connfd is closed!\n", getpid());
            fprintf(fp_res, "[cli](%d) child process is going to exit!\n", getpid());
            fprintf(fp_res, "[cli](%d) stu_cli_res_%d.txt is closed!\n", getpid(), i+1);
            printf("[cli](%d) connfd is closed!\n", getpid());
            printf("[cli](%d) child process is going to exit!\n", getpid());
            printf("[cli](%d) stu_cli_res_%d.txt is closed!\n", getpid(), i+1);
            
            fclose(fp_res);       
            exit(1);
        }
        i++;
    }

        char  file_name_cli[50];
        sprintf(file_name_cli, "stu_cli_res_%d.txt", 0);
        FILE * fp_res;
        fp_res = fopen(file_name_cli, "ab"); 
        if(!fp_res){
            printf("[cli](%d) child exits, failed to open file \"stu_cli_res_%d.txt\"!\n", getpid(), 0);
            exit(-1);
        }

        
        printf("[cli](%d) stu_cli_res_%d.txt is created!\n", getpid(), 0);
        fprintf(fp_res, "[cli](%d) parent process  is created!\n", getpid());

        int clientfd;
        if((clientfd = socket(PF_INET, SOCK_STREAM, 0)) == -1){
            printf("editor: create socket error in child process %d, exit...\n", getpid());
            exit(0);
        }
        while(1){
            int  con_res;

            con_res = connect(clientfd, (struct sockaddr *)&srv_addr, sizeof(srv_addr));
            if(con_res == 0){
                fprintf(fp_res, "[cli](%d) server[%s:%s] is connected!\n", getpid(), argv[1], argv[2]);
                char  ip_str[50];
                if(echo_rqt(clientfd, 0, fp_res) == 0){
                    close(clientfd);
                    break;
                }
                else{
                    printf("editor: some error happened in echo_rqt, in child_process :%d\n",getpid());

                }
            }
            else{
                if(sig_chld_id){
                    printf("editor: int happened\n");
                }
                fclose(fp_res);
                exit(0);
            }
        }
        fprintf(fp_res, "[cli](%d) connfd is closed!\n", getpid());
        fprintf(fp_res, "[cli](%d) child process is going to exit!\n", getpid());
        fprintf(fp_res, "[cli](%d) stu_cli_res_%d.txt is closed!\n", getpid(), 0);
        printf("[cli](%d) connfd is closed!\n", getpid());
        printf("[cli](%d) child process is going to exit!\n", getpid());
        printf("[cli](%d) stu_cli_res_%d.txt is closed!\n", getpid(), 0);
        
        fclose(fp_res);
        exit(0);
    
}

tcp_echo_srv.c

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

#define MAX_CMD_STR 100
#define BACKLOG 1024
#define bprintf(fp, format, ...) \
    if(fp == NULL){printf(format, ##__VA_ARGS__);}  \
    else{printf(format, ##__VA_ARGS__); \
            fprintf(fp, format, ##__VA_ARGS__);fflush(fp);} 

int sig_type = 0;

void sig_int(int signo) {   
    sig_type = signo;
    printf("[srv](%d) SIGINT is coming!\n", getpid());
    return;
}
void sig_pipe(int signo) {  
    sig_type = signo;
    printf("[srv](%d) SIGPIPE is coming!\n", getpid());
}
void sig_chld(int signo){
    int stat;
    sig_type = signo;
    pid_t pid_chld;
    printf("[srv](%d) SIGCHLD is coming!\n", getpid());
    while((pid_chld = waitpid(-1, NULL, WNOHANG))> 0){
        printf("[srv](%d) server child(%d) terminated.\n", getpid(), pid_chld);
    };
}

int sig_handlers(void){
    
    struct sigaction sigact_pipe, sigact_pipe_old;
    sigact_pipe.sa_handler = sig_pipe;//sig_pipe()，信号处理函数
    sigact_pipe.sa_flags = 0;
    sigact_pipe.sa_flags |= SA_RESTART;//设置受影响的慢系统调用重启
    sigemptyset(&sigact_pipe.sa_mask);
    sigaction(SIGPIPE, &sigact_pipe, &sigact_pipe_old);
    
    struct sigaction sigact_chld, sigact_chld_old;
    sigact_chld.sa_handler = sig_chld;
    sigact_chld.sa_flags |= SA_RESTART;
    sigemptyset(&(sigact_chld.sa_mask));
    sigaction(SIGCHLD, &sigact_chld, &sigact_chld_old);

    struct sigaction sigact_int, sigact_int_old;
    sigact_int.sa_handler = sig_int;
    sigact_int.sa_flags = 0;
    sigemptyset(&(sigact_int.sa_mask));
    sigaction(SIGINT, &sigact_int, &sigact_int_old);
    return 0;
}

int echo_rep(int sockfd, FILE *fp_res)
{
    int len_h, len_n;
    int pin_h, pin_n;
    int count;
    char buf[MAX_CMD_STR];
    int flag = 0;
    while(1){
        flag = read(sockfd, &pin_n, 4);
        if(flag < 0){
            if(errno == EINTR){
                if(sig_type == SIGINT){
                    return -1;
                }
                continue;
            }
            continue;
        }
        else if(flag == 0){
            return pin_h;
        }
        if(!read(sockfd, &len_n, 4)){
            printf("editor: no data\n");
        }
        pin_h = ntohl(pin_n);
        len_h = ntohl(len_n);
        count = 0;
        int temp = 0;
        while(count < len_h){
            temp = read(sockfd, buf + count, len_h - count);
            if(!temp){
                printf("id: %d, editor: no data!!\n", getpid());
                return -1;
            }
            count += temp;
        }
        fprintf(fp_res, "[echo_rqt](%d) %s\n",getpid(), buf);
        if(send(sockfd, &pin_n, 4, 0) == -1){
            printf("editor: send data error pin, errno:%d!\n", errno);
        }
        if(send(sockfd, &len_n, 4, 0) == -1){
            printf("editor: send data error len!\n");
        }
        if(send(sockfd, buf, len_h, 0) == -1){
            printf("editor: send data error buf!\n");
        }

    }

}

int main(int argc, char* argv[])
{
    
    if(argc != 3)
    {
        printf("Usage:%s <IP> <PORT>\n", argv[0]);
        return -1;
    }
    FILE * fp_res;
    fp_res = fopen("stu_srv_res_p.txt", "wb");
    fflush(fp_res);
    if(!fp_res){
        printf("[srv](%d) failed to open file \"stu_srv_res_p.txt\"!\n", getpid());
        return 0;
    }
    else{
        printf("[srv](%d) stu_srv_res_p.txt is opened!\n", getpid());
    }
    
    sig_handlers();

    struct sockaddr_in  srv_addr, cli_addr;
    int listenfd, connfd, cli_addr_len;
    bzero(&srv_addr, sizeof(srv_addr));
    srv_addr.sin_family = AF_INET;
    inet_pton(AF_INET, argv[1], &(srv_addr.sin_addr));
    srv_addr.sin_port = htons(atoi(argv[2]));

    fprintf(fp_res, "[srv](%d) server[%s:%s] is initializing!\n",getpid(), argv[1], argv[2]);

    if((listenfd = socket(PF_INET, SOCK_STREAM, 0)) == -1){
        printf("editor: create socket error in child process %d, exit...\n", getpid());
        exit(0);
    }
    int opt = SO_REUSEADDR;
	setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));	//将地址和端口设为可立即重用

    if (bind(listenfd, (struct sockaddr *)&srv_addr, sizeof(srv_addr)) == -1)
    {
        printf("editor: bind socket error, \n");
        exit(0);
    } 
    if(listen(listenfd, BACKLOG)){
        printf("editor: listen error!\n");
    }
    int cli_addr_size;
    char cli_addr_str[32];
    short int cli_port;
    cli_addr_len = sizeof(struct sockaddr_in);
    while(1){
        if((connfd = accept(listenfd, (struct sockaddr*)(&cli_addr), &cli_addr_len)) == -1){
            if(errno == EINTR){
                if(sig_type = SIGINT){
                    break;
                }
            }
            else{
                close(connfd);//与restart作用相同
                continue;
            }
        }
        inet_ntop(AF_INET, &(cli_addr.sin_addr.s_addr), cli_addr_str, sizeof(cli_addr));
        cli_port = ntohs(cli_addr.sin_port);
        fprintf(fp_res, "[srv](%d) client[%s:%hu] is accepted!\n",getpid(), cli_addr_str, cli_port);
        
        fflush(fp_res);
        int pid = 0;
        pid = fork();
        if(pid == -1){
            printf("unexpected error!\n");
            return -1;
        }
        else if(pid == 0){
            fclose(fp_res);
            close(listenfd);
            char filename_res[50];
            char filename_res_new[60];
            sprintf(filename_res, "stu_srv_res_%d.txt", getpid());
            fp_res = fopen(filename_res, "wb");
            printf("[srv](%d) stu_srv_res_%d.txt is opened!\n", getpid(), getpid());
            fprintf(fp_res, "[cli](%d) child process is created!\n", getpid());
            int tt_val;
            tt_val = 0;
            if((tt_val = echo_rep(connfd, fp_res)) == -1){
                printf("some error may happened in echo_rep\n");
            }
            else{
                sprintf(filename_res_new, "stu_srv_res_%d.txt", tt_val);
                if(!rename(filename_res, filename_res_new)){
                    fprintf(fp_res, "[srv](%d) res file rename done!\n", getpid());
                }
                else{
                    printf("res file name error!\n");
                }
            }
            close(connfd);
            fprintf(fp_res, "[srv](%d) connfd is closed!\n", getpid());
            fprintf(fp_res, "[srv](%d) child process is going to exit!\n", getpid());
            fclose(fp_res);
            printf("[srv](%d) stu_cli_res_%d.txt is closed!\n", getpid(), getpid());
            exit(0);
        }
        close(connfd);
    }
    fprintf(fp_res, "[srv](%d) listenfd is closed!\n", getpid());
    fprintf(fp_res, "[srv](%d) parent process is going to exit!\n", getpid());
    fclose(fp_res);
    close(listenfd);
    printf("[srv](%d) stu_srv_res_p.txt is closed!\n", getpid());
    return 0;
}
xxx123112
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
百万级别长连接，并发测试指南
weixin_33674976的博客
03-22 3095
前言 都说haproxy很牛x, 可是测试的结果实在是不算满意, 越测试越失望,无论是长连接还是并发, 但是测试的流程以及工具倒是可以分享分享。也望指出不足之处。 100w的长连接实在算不上太难的事情，不过对于网上关于测试方法以及测试工具的相关文章实在不甚满意，才有本文。 本文有两个难点,我算不上完全解决。 后端代码的性能. linux内核参数的优化. 环境说明 下面所有的测试机器都是基于op...
多进程并发TCP服务器模型（含客户端）（网络编程 C语言实现）
weixin_56187542的博客
08-18 2439
大家都知道不同pc间的通信需要用到套接字sockte来实现，但是服务器一次只能收到一个客户端发来的消息，所以为了能让服务器可以接收多个客户端的连接与消息的传递，我们就引入了多进程并发这样一个概念。： 每连接一个客户端，创建一个子进程，子进程负责处理connfd(客户请求)recv(), read(), recvfrom()　数据接收。send(), write(), sendto()　数据发送。close(), shutdown()　关闭套接字。父进程处理sockfd(连接请求)。...
千万级别并发用户模拟软件 tcpburn.zip
09-17
千万级别并发用户模拟软件 tcpburn ,tcpburn是由网易自主研发的能够模拟千万级别并发用户的一个软件，目的是能够用较少的资源来模拟出...
千万并发不是梦：TCPBurn并发测试
chugairan0032的博客
05-14 323
王斌 TCPCopy和Cetus开源主要作者 知识星球ID: 47406575，提供TCP经典案例分析课程 ...
【工具】开发工具红黑榜 （TCP测试/HTTP测试/SHELL工具/串口工具……）
bandaoyu的note
01-09 4082
SSH工具 FinalShell （shell+文件传输+远程桌面） SSH/串口 工具 MobaXterm Xshell （缺点：收费） TCP/UDP测试工具 红： USR-TCP232-Test（功能强大）http://www.usr.cn/Download/27.html SocketTool.exe （缺点：没有日志功能，点击发送后发送框内的数据被清除） 灰： T............
TCP服务器的单进程、多进程实现
everthing willl be ok
05-08 3219
一、socket编程 在理解TCP服务器时，我们必须了解socket编程，在上篇博客中，我们知道在TCP/IP协议中，“IP地址+TCP端口号/UDP端口号”唯一标识网络通讯中的唯一一个进程，我们把“IP地址+端口号”就成为socket。 在TCP协议中,建立连接的两个进程各自有一个socket来标识,那么这两个socket组成 的socketpair就唯一标识一个连接。socket本身有“插...
c语言多进程tcp服务器示例
01-20
server.h 代码如下:#ifndef SERVER_H#define SERVER_H#include <sys>#include <sys>#include <netinet>#include <stdio>#include <stdlib>#include <unistd>#include <arpa>#include <assert>#include <sys>#...
linux多进程tcp服务器.rar
04-05
在Linux系统中，多进程TCP服务器是一种常见的网络编程模型，用于构建高性能、高并发的网络服务。本资源“linux多进程tcp服务器.rar”提供了一套用易语言编写的多进程TCP服务器源码，旨在帮助开发者理解和实践这一...
TCP多进程并发TCP多进程并发
12-27
TCP多进程并发是实现高性能服务器的一种常见技术，它利用操作系统的多进程特性来同时处理多个客户端连接请求，以提高系统的服务能力。 在传统的单进程模型中，一个进程只能处理一个连接，当有新的连接请求时，必须...
linux并发回音服务器与客户端
06-17
3. **并发处理**：在“并发回音服务器”中，为了同时处理多个客户端请求，通常会使用多线程或多进程模型。当服务器接收到新的连接请求时，它会创建一个新的线程或进程来处理该请求，主进程继续监听新的连接，实现...
linux多进程并发执行实验
10-23
（一）多进程并发执行是使用后台任务来实现任务的“多进程化”。在不加控制的模式下，不管有多少任务，全部都后台执行。也就是说，在这种情况下，有多少任务就有多少“进程”在同时执行。 （二）实验中要用到的函数 1、fork（）函数——进程创建函数。 2、getpid（）函数——取得目前进程的进程标识码。 3、exit（）函数——用来正常终结目前进程的执行。 4、sleep（）函数——用来延时，它会被挂起，把处理器让给其他的进程。 5、printf（）函数——是格式化输出函数, 一般用于向标准输出设备按规定格式输出信息。
tcp并发服务器之线程
ubuntucc的专栏
07-31 825
关于进程和线程的知识，请看我相关的简单博文，不足之处，请之处，相互学习 ////tcp并发服务器之线程 1 #include   2 #include   3 #include   4 #include   5 #include   6    7 #include          /* See NOTES */   8 #include   9 #include
Linux：tcp多进程&多线程通信
qq_45481606的博客
08-27 600
tcp多进程编程：让子进程和客户端进行通信 父进程调用accept函数，接收新连接完毕之后，再创建子进程 代码： 当多个客户端与服务端连接时，服务端就会创建出两个子进程提供数据交互 父进程进行accept，子进程进行recv和send 当客户端关闭连接，服务端子进程也就没有必要再去连接客户端，所以子进程运行至54行执行exit函数退出；但是子进程先于父进程退出，子进程就变成了僵尸进程，每当服务端关闭一次，就会多产生一个僵尸进程； 解决方案：使用signal函数修改SIGCHLD信号的处理方式
【测试】单机模拟100万并发|单机模拟百万客户端tcpburn|千万并发不是梦：TCPBurn并发测试
bandaoyu的note
09-10 2349
概念类比 待压测的服务器应用：城池； 测试软件：攻城军队； 测试软件需要做的就是构造出成千上百万的士兵，来攻占服务器的应用。 工具和原理 TCPBurn是一个关注并发的重放工具。
实现TCP并发服务器
weixin_47783699的博客
11-25 2538
详解实现TCP并发服务器两种方法:1、使用多进程实现TCP并发服务器2、使用多线程实现TCP并发服务器。
Linux信号学习笔记(3)
weixin_43979272的博客
12-05 633
Linux信号学习笔记(3) sigaction sigaction的介绍   先在终端使用"man sigaction"可以查看sigaction相关的解释。可以得到sigaction相关的结构体如下： struct sigaction { void (*sa_handler)(int); void (*sa_sigaction)(int, siginfo_t *, void *); sigset_t sa_mask; int sa_flags; void (*sa_restorer)(void
Tcp服务端服务多个客户端实例（超级详细的注释，简单易懂！）
BlockchainY的博客
07-14 1556
关于这个案例，我们首先具备以下知识：1.tcp协议；2.端口和端口号；3.套接字。 代码如下： import socket import threading # 处理客户端请求的任务 def client_request(ip_port,new_client): print('客户端的ip地址和端口号：', ip_port) # 5.接收客户端数据 # 收发消息都使用返回新的套接字 while True: #循环接收客户端的数据 recv_data = ...
进程对象的其他方法、守护进程、使用多进程实现 socket tcp协议 server端的并发（抢票程序）、队列、进程之间的通信（IPC）...
weixin_30467087的博客
01-26 154
# 进程对象的其他方法 from multiprocessing import Process import time class MyProcess(Process): def __init__(self, a, b): # 为了给子进程传递参数 super().__init__() self.a = a ...
unix环境IPC编程套接字（一，TCP通信实例
perfect1t的博客
09-26 292
unix环境IPC编程套接字（一，TCP通信实例
tcp多进程并发服务器与多进程客户端
最新发布
06-28
TCP多进程并发服务器和多进程客户端是一种网络编程模型，用于实现高并发的网络通信。在这种模型中，服务器和客户端都使用多个进程来处理并发连接请求，从而提高系统的处理能力和响应速度。 TCP多进程并发服务器通常...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值