c++ 网络编程（三） LINUX/windows 进程间的通信原理与实现代码 基于多进程的服务端实现

原文作者：aircraft

原文链接：https://www.cnblogs.com/DOMLX/p/9613027.html

本网络编程入门系列博客是连载学习的，有兴趣的可以看我博客其他篇。。。。c++ 网络编程课设入门超详细教程 ---目录

 锲子：进程与线程是什么，他们的区别在哪里：

1 进程概念

进程是程序的一次动态执行过程。程序本身只是指令的集合，进程才是程序的真正运行，用户运行程序就产生了进程，用户关闭程序就结束了进程。一个程序可以产生多个进程，但一个进程只能由一个程序产生。进程有5种生命周期状态：创建、就绪、运行、阻塞、退出，下图表示了5种状态之间的关系。

与上面的5种状态不同，在Linux中使用top命令查看进程也有5种状态，但它是以不同的角度来描述进程状态：
R：运行状态，正在运行或在运行队列中等待
S：可中断（自愿）的睡眠状态，在等待某事件发生才可唤醒。如网页服务器的httpd进程，在客户端（浏览器）发出请求之前，服务器无事可做，选择睡眠。是程序角度的睡眠，程序本身控制自己的运行状态
D：不可中断（非自愿）的睡眠状态，有时两个进程试图同时访问同一系统资源，例如一个进程试图从磁盘数据块上读取信息，而另一个进程正在向该数据块写入信息。在这种情况下，内核迫使进程进入非自愿睡眠状态，该进程并没有自愿选择睡眠。当资源被释放时，内核会唤醒进程并将其设置为可运行状态。虽然进程断的进入和离开非自愿睡眠，但是它们通常不会在该状态停留太久。因此，除了在高负荷的系统上，用户通常看不到处于非自愿睡眠状态的进程。
T：停止或跟踪状态，进程收到SIGSTOP, SIGSTP, SIGTIN, SIGTOU信号后停止运行
Z：僵死状态，子进程先于父进程退出，同时父进程又没有调用wait()或waitpid()，则该子进程将成为僵尸进程。为了防止产生僵尸进程，在fork子进程之后我们都要在父进程wait它们

2 线程概念

早期的计算机系统只有进程，没有线程，后来发现进程切换的开销有点大，于是产生了线程（也称轻量级进程），线程切换比进程切换的开销要小很多。线程是程序执行中一个单一的顺序控制流，是程序执行流的最小单元，是处理器调度和分派的基本单位，是进程中代码的不同执行路线，一个进程可以有多个线程。
现在的处理器一般是双核或四核的，每个处理核心对应一个内核线程，但是我们经常看到双核心四线程或四核心八线程的描述，这其实是采用了超线程技术将一个物理处理核心模拟成两个逻辑处理核心，对应两个内核线程，所以采用了超线程技术的CPU在操作系统中看到的CPU数量是实际物理CPU数量的两倍。这里讲到了内核线程，内核线程（Kernel Thread， KLT）就是直接由操作系统内核支持的线程，这种线程由内核来完成线程切换，内核通过操作调度器对线程进行调度，并负责将线程的任务映射到各个处理器上。而用户程序一般是创建用户线程，然后用户线程调用内核线程，在现在流行的操作系统中，用户线程和内核线程是多对多的映射调用关系。

3 进程、线程的区别与联系

一个程序至少产生一个进程，一个进程至少产生一个线程，线程再映射到内核线程，在处理器上完成计算任务。
进程与线程的区别，关键就在于它们独立拥有的资源不同，因此就体现出了不同的特性，主要有以下几方面的不同：
（1）资源
进程作为除CPU以外系统资源的分配单位，每个进程都拥有独立的地址空间和资源，因此一个进程崩溃不会引起其他进程的运行，就好像是不同程序创建的不同进程互不影响一样；
线程作为CPU的分配单位，是被系统独立调度和分派的基本单位，本身仅拥有CPU中的寄存器和线程函数调用需要的堆栈区这一点点资源，其他资源如代码、公有数据、文件描述符等都是与其他线程共享的进程资源，所以一个线程崩溃，整个进程都崩溃。
（2）系统开销
由于每个进程都拥有独立的地址空间和资源，因此进程的创建和撤销都需要资源的分配和回收，系统开销大；
每个线程仅仅拥有一点必不可少的资源，所以创建和撤销都很快。
（3）通信方式
进程之间主要有6种通信方式：管道、信号、消息队列、共享内存、信号量、socket；
线程之间主要有3种通信方式：锁机制（包括互斥锁、条件变量、读写锁）、信号量机制、信号机制。
线程间的通信目的主要是用于线程同步，所以线程没有像进程通信中的用于数据交换的通信机制。
通信方式的内容写得不够详细，后续再补充，下面这些是暂时记录的内容：

信号量：一个初始值为N的信号量允许N个线程并发访问。线程访问资源时首先获取信号量锁，进行如下操作：
1. 将信号量的值减1；
2. 如果信号量的值小于0，则进入等待状态，否则继续执行；
访问资源结束之后，线程释放信号量锁，进行如下操作：
1. 将信号量的值加1；
2. 如果信号量的值小于1(等于0)，唤醒一个等待中的线程；
同步：多个事件一起开始，一起结束（一刀切）；
异步：多个事件各走各的，完成了通知一下控制中心；
阻塞：所申请资源被占用、启动IO传输未完成，必须等待资源或事件完成才可以进行下一步称为阻塞；
挂起：挂起是主动的，一般需要用挂起函数进行操作，若没有resume的动作，则此任务一直不会ready，而阻塞是因为资源被其他任务抢占而处于休眠态。

一.进程间通信的基本概念

进程间通信意味着两个不同进程间可以交换数据，操作系统中应提供两个进程可以同时访问的内存空间。

 

多进程之间通信方式：

          文件映射：本地之间

          共享内存：本地之间

          匿名管道：本地之间

          命名管道：跨服务器

          邮件槽：一对多的传输数据，通常通过网络向一台Windows机器传输

          剪切板：本地之间

          socket：跨服务器

多线程之间通信方式：

          全局变量

          自定义消息响应

多线程之间同步机制：

          临界区：不可以跨进程，忘记解锁会无限等待，要么存在要么没有，多线程访问独占性共享资源

          互斥量：可以跨进程，忘记解锁会自动释放，要么存在要么没有

          事件：又叫线程触发器，不可以跨进程，要么存在要么没有，一个线程来唤醒另一个线程（包括自动和人工两种方式）

          信号量：可以跨进程，始终代表可用资源数量，当资源数为o时，线程阻塞，允许多个线程同时访问一个共享资源

 

通过管道实现进程间通信

基于管道(PIPE)的进程间通信结构模型：

                                                

通过管道完成进程间通信。管道不是进程的资源，属于操作系统的。两个进程通过操作系统提供的内存空间进行通信。

创建管道的函数：

 

父进程调用该函数时创建管道，同时获取对应于出入口的文件描述符。父进程的目的是与子进程进行数据交换，因此需要将入口或出口中的1个文件描述符传递给子进程。调用fork函数传递。

 

二.进程间通信的单向传递

 

简单的看一个基础单向通信实例代码来理解进程间的通信是怎么实现的：

#include<stdio.h>
#include<unistd.h>
#define BUF_SIZE 30
 
int main(int argc, char *argv[])
{
    int fds[2];
    char str[] = "Who are you?";
    char buf[BUF_SIZE];
    pid_t pid;
 
    pipe(fds);                //创建管道,fds数组中保存用于I/O的文件描述符
    pid = fork();            //子进程将同时拥有管道的I/O文件描述符。
    if (pid == 0)
    {
        write(fds[1],str,sizeof(str));        //fds[1]为管道入口
    }
    else 
    {
        read(fds[0],buf,BUF_SIZE);            //fds[0]为管道出口    
        puts(buf);
    }
    return 0;
}

运行结果：who are you ?

 

上例中，父子进程都可以访问管道的I/O路径，但子进程仅用输入路径，父进程仅用输出路径。

                                        

 

三.进程间通信的双向传递

 

管道进行双向数据交换的通信方式：

                                        

 

接下来看一个简单的实例代码：

/* 双向通信的管道 */
#include<stdio.h>
#include<unistd.h>
#define BUF_SIZE 30
 
int main(int argc,char *argv[])
{
    int fds[2];
    char str1[] = "Who are you?";
    char str2[] = "Thank you for your message!";
    char buf[BUF_SIZE];
    pid_t pid;
 
    pipe(fds);
    pid = fork();
    if (pid == 0)
    {
        write(fds[1],str1,sizeof(str1));        //传输数据
        sleep(2);                               //睡眠两秒，避免被下一行的read函数读取了数据。
        read(fds[0],buf,BUF_SIZE);
        printf("Child proc output: %s 
",buf);    //接收数据
    }
    else 
    {
        read(fds[0],buf,BUF_SIZE);                //接收数据
        printf("Parent proc output: %s 
",buf);
        write(fds[1],str2,sizeof(str2));        //传输数据
        sleep(3);        //睡眠,防止父进程在子进程输出之前结束，可删除
            //不理解的话你注释掉这个sleep体会一下就知道了
    }
    return 0;
}

这里为什么有这么多个sleep 呢，摇一摇你们的小脑袋----有没有听见水声？？？hhh

书上有句话“向管道传递数据的时候，先读的程序会把数据先取走”

看到这里明白了吗？？？  简而言之就是数据进入管道就变成了无主数据，这时候如果我子进程先写入数据，在父进程没有取出数据前又read把自己的数据给读出来了！！！！大问题！大问题！对吧，这是要搞事情的节奏啊，被谁打死都不知道！！！

那么如何避免这个问题呢？---一个管道不够，我建两个呗---唉，真是的。。。。。

只用1个管道进行双向通信并非易事，需要预测并控制运行流程。因此创建2个管道完成双向通信，各自负责不同的数据流动即可：

                                            

由上图可知，是用2个管道可以避免程序流程的预测或控制。

接下来看双通道实现通信代码：

/* 双管道实现进程间通信 */
#include<stdio.h>
#include<unistd.h>
#define BUF_SIZE 30
 
int main(int argc,char *argv[])
{
    int fds1[2],fds2[2];
    char str1[] = "Who are you?";
    char str2[] = "Thank you for your message!";
    char buf[BUF_SIZE];
    pid_t pid;
 
    pipe(fds1), pipe(fds2);                        //创建两个管道
    pid = fork();
    if (pid == 0)
    {
        write(fds1[1],str1,sizeof(str1));    //子进程通过数组fds1传输数据
        read(fds2[0],buf,BUF_SIZE);
        printf("Child proc output: %s 
",buf);
    }
    else 
    {
        read(fds1[0],buf,BUF_SIZE);
        printf("Parent proc output: %s 
",buf);    
        write(fds2[1],str2,sizeof(str2));    //父进程通过数组fds2传输数据
        sleep(3);
    }
    return 0;
}

输入结果：Parent proc output: ”Who are you?"; 

Child proc output: "Thank you for your message!";

好的基本概念都介绍完了，那我们用一下玩玩呗？？？

四.基于多进程的回声服务端实现

注意啦这里是对我上一章博客代码的扩充，没有看我的上一张网络编程（二)......可以去看看了

这里对网络编程（二）加了一个功能，“可以将回声客户端传输的字符串按序保存到文件中去”

 LINUX 下：

/* 实现并发服务器端 */
/* echo_storeserv.c */
#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 100
void error_handling(char *message)
{
    fputs(message,stderr);
    fputc('
',stderr);
    exit(1);
}
 
/* Handler */
void read_childproc(int sig)
{
    pid_t pid;
    int status;
    pid = waitpid(-1,&status,WNOHANG);
    printf("removed proc id: %d 
",pid);
}
 
int main(int argc, char *argv[])
{
    int serv_sock, clnt_sock;
    struct sockaddr_in serv_adr, clnt_adr;
    int fds[2];
 
    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> 
",argv[0]);
        exit(1);
    }
 
    act.sa_handler = read_childproc;            //设置信号处理函数
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    state = sigaction(SIGCHLD,&act,0);            //子进程终止时调用Handler
    
    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");
 
    pipe(fds);
　　//这里创建一个子进程来服务写入文件数据
    pid = fork();
    if (pid == 0)
    {
        FILE* fp = fopen("echomsg.txt","wt");
        char msgbuf[BUF_SIZE];
        int i, len;
 
        for (i = 0; i < 10; i++ )
        {
            len = read(fds[0],msgbuf,BUF_SIZE);    //从管道出口fds[0]读取数据并保存到文件中
            fwrite((void*)msgbuf,1,len,fp);        
        }
        fclose(fp);
        return 0;
    }
 
 
    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 == 0)        //子进程运行区域
        {
            close(serv_sock);
            while((str_len = read(clnt_sock,buf,BUF_SIZE)) != 0)
            {    
                write(clnt_sock,buf,str_len);
                write(fds[1],buf,str_len);        //将从客户端接收到的数据写入到管道入口fds[1]中
            }
 
            close(clnt_sock);
            puts("client disconnected...");
            return 0;        //调用Handler
        }
        else                //父进程运行区域
            close(clnt_sock);
    }
    close(serv_sock);
    return 0;
} 

上面处理文件的进程代码里，可能有的人会对那个for循环怎么实现恰好读十次数据结束，，，有点疑惑------关键在于read函数，这个函数如果没有从管道里面读取到数据就会继续等待！！！  这也是大工程需要注意出现BUG的地方

这里需要大家多开几个客户端来验证服务端的效果，当10次fwrite函数调用完后，大家就可以打开文件查看结果了，如果没有客户端代码可以参考我上一篇博客。

windows下基于多进程的回声服务端实现代码：

/*
 *  @file  : TestEchoServerMultiProcess.cpp
 *  @author: Shilyx
 *  @date  : 2014-04-23 08:43:27.206
 *  @note  : Generated by SlxTemplates， 多进程echo服务器演示
 */
 
#include <WinSock2.h>
#include <Windows.h>
#include <Shlwapi.h>
#pragma warning(disable: 4786)
#include <iostream>
 
#pragma comment(lib, "Ws2_32.lib")
#pragma comment(lib, "Shlwapi.lib")
 
using namespace std;
 
// 初始化WinSock，未检查返回值
void InitWinSock()
{
    WSADATA wd;
 
    WSAStartup(MAKEWORD(2, 2), &wd);
}
 
void Serve(USHORT port)
{
    InitWinSock();
 
    SOCKET sock_base = INVALID_SOCKET;
 
    do
    {
        sock_base = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 
        if (sock_base == INVALID_SOCKET)
        {
            cerr<<"socket error "<<WSAGetLastError()<<endl;
            break;
        }
 
        sockaddr_in sin;
 
        sin.sin_family = AF_INET;
        sin.sin_addr.s_addr = INADDR_ANY;
        sin.sin_port = htons(port);
 
        if (SOCKET_ERROR == bind(sock_base, (sockaddr *)&sin, sizeof(sin)))
        {
            cerr<<"bind error "<<WSAGetLastError()<<endl;
            break;
        }
 
        if (SOCKET_ERROR == listen(sock_base, 100))
        {
            cerr<<"listen error "<<WSAGetLastError()<<endl;
            break;
        }
 
        HANDLE hProcess = NULL;
        DuplicateHandle(GetCurrentProcess(), GetCurrentProcess(), GetCurrentProcess(), &hProcess, 0, TRUE, DUPLICATE_SAME_ACCESS);
 
        if (NULL == hProcess)
        {
            cerr<<"DuplicateHandle error "<<GetLastError()<<endl;
            break;
        }
 
        TCHAR szSelfPath[MAX_PATH];
 
        GetModuleFileName(GetModuleHandle(NULL), szSelfPath, RTL_NUMBER_OF(szSelfPath));
        PathQuoteSpaces(szSelfPath);
 
        while (true)
        {
            int len = sizeof(sin);
            SOCKET sock = accept(sock_base, (sockaddr *)&sin, &len);
 
            if (sock == INVALID_SOCKET)
            {
                cerr<<"accept error "<<WSAGetLastError()<<endl;
                break;
            }
            else
            {
                TCHAR szCommand[MAX_PATH * 2];
                STARTUPINFO si = {sizeof(si)};
                PROCESS_INFORMATION pi;
 
                si.dwFlags = STARTF_USESHOWWINDOW;
                si.wShowWindow = SW_SHOW;
 
                wnsprintf(szCommand, RTL_NUMBER_OF(szCommand), TEXT("%s %u %u"), szSelfPath, sock, hProcess);
 
                if (CreateProcess(NULL, szCommand, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi))
                {
                    CloseHandle(pi.hProcess);
                    CloseHandle(pi.hThread);
                }
                else
                {
                    cerr<<"CreateProcess error "<<GetLastError()<<endl;
                }
 
                closesocket(sock);
            }
        }
 
    } while (false);
 
    if (sock_base != INVALID_SOCKET)
    {
        closesocket(sock_base);
    }
}
 
DWORD CALLBACK WorkProc(LPVOID lpParam)
{
    SOCKET sock = (SOCKET)lpParam;
 
    while (TRUE)
    {
        char szBuffer[4096];
        int len = recv(sock, szBuffer, sizeof(szBuffer), 0);
 
        if (len <= 0)
        {
            break;
        }
 
        if (send(sock, szBuffer, len, 0) <= 0)
        {
            break;
        }
    }
 
    closesocket(sock);
 
    return 0;
}
 
void Work(SOCKET sock, HANDLE hParentProcess)
{
    InitWinSock();
 
    HANDLE hObjects[] = {hParentProcess, CreateThread(NULL, 0, WorkProc, (LPVOID)sock, 0, NULL)};
 
    WaitForMultipleObjects(RTL_NUMBER_OF(hObjects), hObjects, FALSE, INFINITE);
 
    CloseHandle(hObjects[0]);
    CloseHandle(hObjects[1]);
}
 
int main(int argc, char *argv[])
{
    // 加端口参数启动为父进程
    // 加套接字句柄参数和进程句柄参数为子进程
    // 不加参数显示用法
 
    if (argc == 2)
    {
        int port = StrToIntA(argv[1]);
 
        if (port < 0 || port > 65535)
        {
            cerr<<"端口错误:"<<port<<endl;
            return 0;
        }
 
        // 在端口port处启动echo服务器
        Serve((USHORT)port);
    }
    else if (argc == 3)
    {
        SOCKET sock = StrToIntA(argv[1]);
        HANDLE hParentProcess = (HANDLE)StrToIntA(argv[2]);
 
        // 针对具体tcp连接套接字和父进程句柄开始echo工作
        Work(sock, hParentProcess);
    }
    else
    {
        cout<<"加端口参数启动为父进程"<<endl
            <<"加套接字句柄参数和进程句柄参数为子进程"<<endl
            <<"不加参数显示用法"<<endl;
    }
 
    return 0;
}

同时多进程服务端也是有缺点的，每创建一个进程就代表大量的运算与内存空间占用，相互进程数据交换也很麻烦。。。那么怎么解决呢，在我后面的博客也许会给出答案-----hhhhhhh

 最后说一句啦。本网络编程入门系列博客是连载学习的，有兴趣的可以看我博客其他篇。。。。

好了今天对网络编程的学习就到这里结束了，小飞机我要撤了去吃饭了。，，，很多人大学都很迷茫不知道学点什么好，，，，，管他的，想那么多干嘛，先学了再说，对技术如有偏见，那么你的领域就局限于此了---《一专多精》

 

 

 

参考博客：https://blog.csdn.net/du_qi/article/details/52372914

参考博客：https://blog.csdn.net/my3439955/article/details/9749869

参考书籍：《TCP/IP 网络编程 --尹圣雨》

 

若有兴趣交流分享技术，可关注本人公众号，里面会不定期的分享各种编程教程，和共享源码，诸如研究分享关于c/c++,python,前端，后端，opencv,halcon,opengl,机器学习深度学习之类有关于基础编程，图像处理和机器视觉开发的知识