Linux 多进程解决客户端与服务器端通信

于 2023-09-02 20:58:17 发布
阅读量447 收藏 1
点赞数
分类专栏： Linux 文章标签： linux 服务器 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NuYoaH502329/article/details/132639269
版权

写一个服务器端用多进程处理并发，使两个以上的客户端可以同时连接服务器端得到响应。每当接受一个新的连接就fork产生一个子进程，让子进程去处理这个连接，父进程只用来接受连接。

与多线程相比的不同点：多线程如果其中一个线程操作不当，产生了一个信号，会导致整个进程都终止。对于多进程来讲，是产生的子进程去处理客户端的连接，如果子进程终止了，不会影响到其他进程。创建线程的开销比产生新的子进程的开销要小，多线程可以共享整个进程的资源。

服务器端代码ser.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<pthread.h>
#include<signal.h>

int socket_init();//封装一个套接字，套接字的声明
void do_run(int c)//子进程中处理客户端的方法的实现
{
    while(1)
    {
        char buff[128]={0};
        int num=recv(c,buff,127,0);//相当于read
        if(num<=0)
        {
            break;
        }
        printf("子进程接收到的信息:%s\n",buff);
        send(c,"ok",2,0);//相当于write
        
    }
}

int main()
{
    
    int sockfd=socket_init();//调用封装好的套接字方法，创建套接字
    if(sockfd==-1)
    {
        printf("创建失败\n");
        exit(1);
    }

    while(1)
    {
        struct sockaddr_in caddr;//定义客户端的套接字地址
        int len = sizeof(caddr);
        //4.接收客户端连接
        int c=accept(sockfd,(struct sockaddr*)&caddr,&len);
        if(c<0)//失败
        {
            continue;
        }

        printf("c=%d\n",c);
        
        //5.产生一个子进程来处理客户端的连接，子进程会复制父进程打开的所有文件，上面接收的客户端的连接c也算是文件描述符，这个c也会被复制到子进程中
        pid_t pid=fork();
        if(pid==-1)  
        {
            printf("子进程产生失败\n"); 
            close(c);//关闭c这个连接
            continue;//重新等待新的连接
        }
        else if(pid==0)//子进程产生成功
        {
            close(sockfd);//因为子进程不用sockfd
            do_run(c);//处理客户端，传入的参数是c这个描述符
            close(c);//子进程在退出之前关闭c
            printf("子进程退出，pid=%d\n",getpid());
            
            exit(0);//处理完所连接的客户端，子进程必须要退出
        }
        else 
        {
            close(c);//父进程关闭c连接，对子进程没有影响，因为在fork之后，描述符的引用计数加1，这时候父进程关闭，子进程也关闭，最终才能认为c被关闭
                 //如果父进程不关闭c连接，c的值会一直增长
        }
        
    }
    
    exit(0);
}


int socket_init()//套接字的具体实现
{
    int sockfd=socket(AF_INET,SOCK_STREAM,0);//1.创建套接字

    if(sockfd==-1)
    {
        printf("创建失败\n");
        return -1;
    }

    struct sockaddr_in saddr;//定义服务器端的套接字地址
    memset(&saddr,0,sizeof(saddr));//清空

    saddr.sin_family=AF_INET;
    saddr.sin_port=htons(6000);
    saddr.sin_addr.s_addr=inet_addr("127.0.0.1");

    //2.绑定，指定套接字的ip和端口
    int res=bind(sockfd,(struct sockaddr*)&saddr,sizeof(saddr));

    if(res==-1)
    {
        printf("绑定失败\n");//ip写错或者端口被占用
        return -1;
    }

    //3.创建监听队列
    res=listen(sockfd,5);
    if(res==-1)
    {
        return -1;
    }

    return sockfd;

}

客户端代码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>

int main()
{
    //1.创建套接字
    int sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd==-1)
    {
        exit(1);
    }

    //要连接服务器端就要知道服务器端的ip和端口，把ip和端口存到下面定义的saddr中
    struct sockaddr_in saddr;
    memset(&saddr,0,sizeof(saddr));//必须清空
    saddr.sin_family=AF_INET;
    saddr.sin_port=htons(6000);
    saddr.sin_addr.s_addr=inet_addr("127.0.0.1");

    //2.连接服务器端
    int res=connect(sockfd,(struct sockaddr*)&saddr,sizeof(saddr));//会随机填充客户端的ip和一个临时端口
    if(res==-1)//网络没联通，服务器端没启动
    {
        printf("连接服务器端失败\n");
        exit(1);
    }

    while(1)
    {
        char buff[128]={0};
        printf("输入：\n");
        fgets(buff,128,stdin);
        if(strncmp(buff,"end",3)==0)
        {
            break;
        }
        //3.向服务器端发送消息
        send(sockfd,buff,strlen(buff),0);
        memset(buff,0,128);
        //4.接收服务器端回复的消息
        recv(sockfd,buff,127,0);
        printf("buff=%s\n",buff);
    }
    //5.关闭客户端
    printf("客户端关闭\n");
    close(sockfd);
}

运行结果：

在这里插入图片描述

此时，虽然两个客户端可以同时与服务器端通信，但是存在一个问题，就是僵死进程的问题，如下图：

在这里插入图片描述

之所以出现僵死进程是因为在子进程结束之后并没有处理子进程，在Linux系统中处理僵死进程的方法有两种，wait和忽略信号。

使用忽略信号的方式，服务器端的代码ser.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<pthread.h>
#include<signal.h>

int socket_init();//封装一个套接字，套接字的声明
void do_run(int c)//子进程中处理客户端的方法的实现
{
    while(1)
    {
        char buff[128]={0};
        int num=recv(c,buff,127,0);//相当于read
        if(num<=0)
        {
            break;
        }
        printf("子进程接收到的信息:%s\n",buff);
        send(c,"ok",2,0);//相当于write
        
    }
}

int main()
{
    signal(SIGCHLD,SIG_IGN);
    
    int sockfd=socket_init();//调用封装好的套接字方法，创建套接字
    if(sockfd==-1)
    {
        printf("创建失败\n");
        exit(1);
    }

    while(1)
    {
        struct sockaddr_in caddr;//定义客户端的套接字地址
        int len = sizeof(caddr);
        //4.接收客户端连接
        int c=accept(sockfd,(struct sockaddr*)&caddr,&len);
        if(c<0)//失败
        {
            continue;
        }

        printf("c=%d\n",c);
        
        //5.产生一个子进程来处理客户端的连接，子进程会复制父进程打开的所有文件，上面接收的客户端的连接c也算是文件描述符，这个c也会被复制到子进程中
        pid_t pid=fork();
        if(pid==-1)  
        {
            printf("子进程产生失败\n"); 
            close(c);//关闭c这个连接
            continue;//重新等待新的连接
        }
        else if(pid==0)//子进程产生成功
        {
            close(sockfd);//因为子进程不用sockfd
            do_run(c);//处理客户端，传入的参数是c这个描述符
            close(c);//子进程在退出之前关闭c
            printf("子进程退出，pid=%d\n",getpid());
            
            exit(0);//处理完所连接的客户端，子进程必须要退出
        }
        else 
        {
            close(c);//父进程关闭c连接，对子进程没有影响，因为在fork之后，描述符的引用计数加1，这时候父进程关闭，子进程也关闭，最终才能认为c被关闭
                 //如果父进程不关闭c连接，c的值会一直增长
        }
        
    }
   
    exit(0);
}


int socket_init()//套接字的具体实现
{
    int sockfd=socket(AF_INET,SOCK_STREAM,0);//1.创建套接字

    if(sockfd==-1)
    {
        printf("创建失败\n");
        return -1;
    }

    struct sockaddr_in saddr;//定义服务器端的套接字地址
    memset(&saddr,0,sizeof(saddr));//清空

    saddr.sin_family=AF_INET;
    saddr.sin_port=htons(6000);
    saddr.sin_addr.s_addr=inet_addr("127.0.0.1");

    //2.绑定，指定套接字的ip和端口
    int res=bind(sockfd,(struct sockaddr*)&saddr,sizeof(saddr));

    if(res==-1)
    {
        printf("绑定失败\n");//ip写错或者端口被占用
        return -1;
    }

    //3.创建监听队列
    res=listen(sockfd,5);
    if(res==-1)
    {
        return -1;
    }

    return sockfd;

}

或者使用wait方法，服务器端的代码ser.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<pthread.h>
#include<signal.h>

int socket_init();//封装一个套接字，套接字的声明
void do_run(int c)//子进程中处理客户端的方法的实现
{
    while(1)
    {
        char buff[128]={0};
        int num=recv(c,buff,127,0);//相当于read
        if(num<=0)
        {
            break;
        }
        printf("子进程接收到的信息:%s\n",buff);
        send(c,"ok",2,0);//相当于write
        
    }
}
void fun(int sig)
{
    wait(NULL);
}
int main()
{

    signal(SIGCHLD,fun);
    
    int sockfd=socket_init();//调用封装好的套接字方法，创建套接字
    if(sockfd==-1)
    {
        printf("创建失败\n");
        exit(1);
    }

    while(1)
    {
        struct sockaddr_in caddr;//定义客户端的套接字地址
        int len = sizeof(caddr);
        //4.接收客户端连接
        int c=accept(sockfd,(struct sockaddr*)&caddr,&len);
        if(c<0)//失败
        {
            continue;
        }

        printf("c=%d\n",c);
        
        //5.产生一个子进程来处理客户端的连接，子进程会复制父进程打开的所有文件，上面接收的客户端的连接c也算是文件描述符，这个c也会被复制到子进程中
        pid_t pid=fork();
        if(pid==-1)  
        {
            printf("子进程产生失败\n"); 
            close(c);//关闭c这个连接
            continue;//重新等待新的连接
        }
        else if(pid==0)//子进程产生成功
        {
            close(sockfd);//因为子进程不用sockfd
            do_run(c);//处理客户端，传入的参数是c这个描述符
            close(c);//子进程在退出之前关闭c
            printf("子进程退出，pid=%d\n",getpid());
            
            exit(0);//处理完所连接的客户端，子进程必须要退出
        }
        else 
        {
            close(c);//父进程关闭c连接，对子进程没有影响，因为在fork之后，描述符的引用计数加1，这时候父进程关闭，子进程也关闭，最终才能认为c被关闭
                 //如果父进程不关闭c连接，c的值会一直增长
        }
        
    }
    
    exit(0);
}


int socket_init()//套接字的具体实现
{
    int sockfd=socket(AF_INET,SOCK_STREAM,0);//1.创建套接字

    if(sockfd==-1)
    {
        printf("创建失败\n");
        return -1;
    }

    struct sockaddr_in saddr;//定义服务器端的套接字地址
    memset(&saddr,0,sizeof(saddr));//清空

    saddr.sin_family=AF_INET;
    saddr.sin_port=htons(6000);
    saddr.sin_addr.s_addr=inet_addr("127.0.0.1");

    //2.绑定，指定套接字的ip和端口
    int res=bind(sockfd,(struct sockaddr*)&saddr,sizeof(saddr));

    if(res==-1)
    {
        printf("绑定失败\n");//ip写错或者端口被占用
        return -1;
    }

    //3.创建监听队列
    res=listen(sockfd,5);
    if(res==-1)
    {
        return -1;
    }

    return sockfd;

}

运行结果：

在这里插入图片描述
在这里插入图片描述
这次僵死进程就不存在了。

嘘yyyyyy
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux-进程间通信
AI_ELF的博客
08-23 6595
数据传输：一个进程需要将它的数据发送给另一个进程资源共享：多个进程之间共享同样的资源。通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。
【Linux网络编程】基于TCP多进程（fork）版本客户端/服务器
春风来不来的博客
06-01 4073
客户端代码： #include #include #include #include #include #include #include #include static usage(const char* proc) { printf("%s [ip] [port\n]", proc); } int main(int argc, char** argv) { if(ar
Linux下Socket编程利用多进程实现一台服务器与多台客户端并发通信
Bit_Dong的博客
02-16 1580
前些日子同“Linux应用编程”专栏中发布过的TCP及UDP在Linux或Windows下的通信都为单进程下的Socket编程，若还存在一些套接字相关函数模糊不清，读者可移步“Socket编程下tcp通信”和“Socket编程下udp通信”重温学习。本篇则是对以上俩篇的一个简单提升运用，或者说是对以后多线程/进程工作的简单示例。PF_INET 和 AF_INET 的区别：在Windows中，AF_INET与PF_INET完全一样，而在Unix/Linux系统中，在不同的版本中这两者有微小差别。
Linux 多线程解决客户端与服务器端通信
最新发布
NuYoaH502329的博客
08-24 455
比如说客户端通过send向服务器端发送数据，那么这个数据就会被写入发送缓冲区中，只要send返回成功就说明所要发送的数据已经成功写入发送缓冲区中。这一行代码的位置，因为此时第一个客户端没有发送消息，所以客户端执行recv的时候发送阻塞，所以服务器端就没有机会执行accept去接收已完成三次握手的监听队列中与第二个客户端建立的连接，因此服务器端的接收缓冲区此时也接收不到第二个客户端从发送缓冲区发送来的数据，所以第二个客户端在执行recv的时候接收不到服务器端给它回复的消息而被阻塞。
linux下socket实现多个客户端向一个服务器端连续发送消息，服务器端使用MQTT转发消息
usstmiracle的博客
11-23 2657
左边同时启动了5个客户端，右边上面是server收界面client消息，右下方是mqtt subscruib 窗口。 本文的实现参考了几篇很不错的博客，下面列出给大家参考： 这是一个聊天室程序，实现多个客户端向一个服务端发送消息，服务端输入消息，可以向所有连接上的客户端广播。 linux下socket编程实现一个服务器连接多个客户端 https://blog.csdn.net/z...
Socket通信：Linux服务器与多个Aandroid客户端
01-29
本文将详细讲解如何实现Linux服务器与多个Android客户端的Socket通信。 首先，我们来理解Socket的基本概念。Socket是网络通信的端点，可以视为连接两台机器的“管道”。在TCP/IP协议栈中，它提供了进程间通信（IPC...
Linux下Socket 多进程多客户端通信
11-05
在这个场景下，我们关注的是如何在Linux环境下利用Socket实现多进程与多客户端的通信。这涉及到并发处理、进程同步以及消息队列管理等多个核心概念。 首先，多进程模型通常用于提高服务器的并发处理能力。每个连接...
linux并发回音服务器与客户端
06-17
3. **并发处理**：在“并发回音服务器”中，为了同时处理多个客户端请求，通常会使用多线程或多进程模型。当服务器接收到新的连接请求时，它会创建一个新的线程或进程来处理该请求，主进程继续监听新的连接，实现...
易语言linux多进程tcp服务器
07-21
《易语言Linux多进程TCP服务器详解》 在IT领域，构建高效的网络服务是至关重要的，尤其是在服务器端。这里我们将深入探讨一个使用易语言在Linux环境下实现的多进程TCP服务器。易语言，作为一款中文编程环境，以其...
linux下服务器和客户端通信.docx
04-23
在Linux环境下，使用C语言进行网络编程可以实现服务器与客户端之间的通信。这涉及到的主要知识点包括套接字（socket）编程、TCP/IP协议族以及多线程（如果需要同时处理多个客户端连接）。以下是对这些概念的详细说明...
linux网络编程:使用多进程实现socket同时收发数据
Biao
09-27 6648
前面已讲过使用一个进程实现服务端和客户端P2P通信的实例，但是它只能同时处理一个客户端的连接。如果要实现并发处理多个客户端的连接并且实现P2P通信，可以使用多进程来处理。相比与多线程来说，多进程耗费的系统资源是比较多的，后续会介绍使用线程池实现简单的数据收发。 使用多进程并发处理多个client请求以及实现P2P通信，父进程专门监听端口，每监听到一个连接就创建一个子进程处理这个客户端，于...
采用fork实现多客户server端
gigglesun的专栏
10-20 1937
一般的socket通信的过程是：服务器在接受来自客户的一个新连接时，会创建出一个新的套接字，而已有的监听套接字将继续接受来自客户端的请求并将它们放入队列中等待处理（调用accept处理）。        由accept获得的套接字描述符在主进程调用fork时，可以被子进程共享，因此，如果accept之后，在子进程中处理连接，在父进程中关闭套接字描述符，就可以处理一个客户端连接了。重复上述的过
linux下共享内存和消息队列实现多进程间数据收发
hsy12342611的专栏
12-11 2216
共享内存和消息队列实现多进程数据收发，execve系统调用参考记录
2-28 共享内存
weixin_44671576的博客
11-16 200
进程间通信： 内存映射：需要有文件操作； 共享内存：直接操作内存，效率最高； 共享内存： 共享内存允许两个或者多个进程共享物理内存的同一块区域（通常被称为段）。由于 一个共享内存段会称为一个进程用户空间的一部分，因此这种 IPC 机制无需内核介 入。所有需要做的就是让一个进程将数据复制进共享内存中，并且这部分数据会对其 他所有共享同一个段的进程可用。 与管道等要求发送进程将数据从用户空间的缓冲区复制进内核内存和接收进程将数据从内核内存复制进用户空间的缓冲区的做法相比，这种 IPC 技术的速度更快.
【Linux】进程间通信——共享内存
qq_53830608的博客
11-11 1774
例2：进程A从键盘循环获取数据并拷贝到共享内存中，进程b从共享内存中获取并打印数据。要求进程a输入一次，进程b输出一次，a不输入，b就不输出。一般给0代表可读可写，可以给SHM_RDONLY 为只读模式，其他为读写。例1：进程A向共享内存写入数据，进程B从共享内存中读取数据并显示。A（./main)未输入时，B（./test）不输出（阻塞着）而输出的时候一直输出S内的数据，没有控制，会一直循环输出。正确流程是写入一次读取一次，不写入不读取。A输入end,A,B退出。A输入一个，B读取一个。
Linux多进程通讯之内存共享
u010304442的博客
05-21 1243
共享内存是一种最为高效的进程间通信方式，进程可以直接读写内存，而不需要任何数据的拷贝。它是IPC对象的一种。为了在多个进程间交换信息，内核专门留出了一块内存区，可以由需要访问的进程将其映射到自己的私有地址空间。进程就可以直接读写这一内存区而不需要进行数据的拷贝，从而大大提高的效率。共享内存允许两个进程访问同一块内存区域，它们使用同一个 key 值标记。 1.1共享内存的创建 函数原型如下： int...
linux进程间通信———内存共享
xy的博客
03-16 8477
共享内存（shared memory）：是linux下的多进程之间的通信方法，这种方法通常用于一个程序的多进程间通信，实际上多个程序间也可以通过共享内存来传递信息。共享内存指在多处理器的计算机系统中，可以被不同中央处理器（CPU）访问的大容量内存。由于多个CPU需要快速访问存储器，这样就要对存储器进行缓存（Cache）。共享内存是存在于内核级别的一种资源，在shell中可以使用ipcs命令来查看当前系统IPC中的状态
Linux开发(九)：多进程通信与同步---共享内存
王木木
03-10 2843
共享内存是进程间通信的一种最基本、最快速的机制。共享内存是两个或多个进程共享同一块内存区域，并通过该内存区域实现数据交换的进程间通信机制。通常是由一个进程开辟一块共享内存区域，然后允许多个进程对此区域进行访问。由于不需要使用中间介质，而是数据由内存直接映射到进程空间，因此共享内存是最快速的进程间通信机制。 共享内存的最大不足之处在于，由于多个进程对同一块内存区具有访问的权限，各个进程之间的同步问题显得尤为突出。必须控制同一时刻只有一个进程对共享内存区域写入数据，否则将造成数据的混乱。但是同步控制的问题，可
linux间多进程通信(共享内存)
赵凯月的博客
09-13 1175
进程间通信
深入探索Linux网络编程：客户端与服务器端解析
套接字是进程间通信的一种方式，特别适用于网络环境。创建套接字后，服务端会调用bind()函数绑定到特定的IP地址和端口号，然后用listen()函数开始监听。当客户端使用connect()函数尝试连接到服务端时，服务端会接收...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值