几种Windows进程通信

2020-01-06 16:25:03 103 收藏
分类专栏： windows c/c++ 文章标签： 进程通信
最后发布:2020-01-06 16:25:03首次发布:2020-01-06 16:25:03
原文链接：https://www.cnblogs.com/zibility/p/5657308.html
版权

32位Windows采用虚拟内存技术使每个进程虚拟4G内存，在逻辑上实现了对进程之间数据代码的分离与保护。那么相应的进程之间的通信也就有必要整理掌握一下。

Windows进程间通讯的方法有很多：管道、邮件槽、剪切板、共享内存、消息、套接字、RPC、DDE等。

但是他们大部分拥有一个共同的本质：利用Windows操作系统高2GB内核共享空间进行数据传递的桥梁，所以他们都是内核对象！

所以他们大部分都要遵循：A创建对象-->A写入数据-->B打开A创建的对象-->B读入数据的规则

 

下面着重通过一些代码Demo来加深下对进程间通信的理解

命名管道

进程A代码

#define READ_PIPE   L"\\\\.\\pipe\\ReadPipe"
#define WRITE_PIPE  L"\\\\.\\pipe\\WritePipe"      //   管道命名


typedef struct _USER_CONTEXT_ 
{
    HANDLE hPipe;
    HANDLE hEvent;
}USER_CONTEXT,*PUSER_CONTEXT;


USER_CONTEXT  Context[2] = {0};

HANDLE hThread[2] = {0};

BOOL  WritePipe();
BOOL  ReadPipe();

BOOL  bOk = FALSE;

DWORD WINAPI WritePipeThread(LPVOID LPParam);
DWORD WINAPI ReadPipeThread(LPVOID LPParam);
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
    int nRetCode = 0;
    HANDLE hPipe = NULL;
    if (WritePipe()==FALSE)
    {
        return -1;
    }
    if (ReadPipe()==FALSE)
    {

        return -1;
    }

    int iIndex = 0;
    while (TRUE)
    {    
        if (bOk==TRUE)
        {
            SetEvent(Context[0].hEvent);
            SetEvent(Context[1].hEvent);

            Sleep(1);
        }
        
        iIndex = WaitForMultipleObjects(2,hThread,TRUE,5000);

        if (iIndex==WAIT_TIMEOUT)
        {
            continue;
        }

        else
        {
            break;
        }

    }

    int i = 0;
    for (i=0;i<2;i++)
    {
        CloseHandle(Context[i].hEvent);
        CloseHandle(Context[i].hPipe);
    }
    CloseHandle(hThread[0]);
    CloseHandle(hThread[1]);
    cout<<"Exit"<<endl;
    return nRetCode;
}


BOOL  WritePipe()
{
    HANDLE hWritePipe = NULL;

    hWritePipe = CreateNamedPipe( 
        WRITE_PIPE,             
        PIPE_ACCESS_DUPLEX,       
        PIPE_TYPE_MESSAGE |    
        PIPE_READMODE_MESSAGE |  
        PIPE_WAIT,               
        PIPE_UNLIMITED_INSTANCES, 
        MAX_PATH,         
        MAX_PATH,
        0,                      
        NULL);            


    if (hWritePipe==INVALID_HANDLE_VALUE)
    {
        return FALSE;
    }

    HANDLE hEvent = CreateEvent(NULL,FALSE,FALSE,NULL);

    Context[0].hEvent = hEvent;
    Context[0].hPipe  = hWritePipe;
    hThread[0] = CreateThread(NULL,0,WritePipeThread,NULL,0,NULL);

    return TRUE;
}



BOOL  ReadPipe()
{
    HANDLE hReadPipe = NULL;

    hReadPipe = CreateNamedPipe( 
        READ_PIPE,             
        PIPE_ACCESS_DUPLEX,       
        PIPE_TYPE_MESSAGE |    
        PIPE_READMODE_MESSAGE |  
        PIPE_WAIT,               
        PIPE_UNLIMITED_INSTANCES, 
        MAX_PATH,         
        MAX_PATH,
        0,                      
        NULL);            

    if (hReadPipe==INVALID_HANDLE_VALUE)
    {
        return FALSE;
    }

    HANDLE hEvent = CreateEvent(NULL,FALSE,FALSE,NULL);

    Context[1].hEvent = hEvent;
    Context[1].hPipe  = hReadPipe;
    hThread[1] = CreateThread(NULL,0,ReadPipeThread,NULL,0,NULL);

    return TRUE;

}

DWORD WINAPI ReadPipeThread(LPVOID LPParam)
{

    HANDLE hEvent     = Context[1].hEvent;
    HANDLE hReadPipe  = Context[1].hPipe;
    DWORD  dwReturn   = 0;

    char szBuffer[MAX_PATH] = {0};
    int  iIndex = 0;
    while (TRUE)
    {

        iIndex = WaitForSingleObject(hEvent,30);

        iIndex = iIndex-WAIT_OBJECT_0;

        if (iIndex==WAIT_FAILED||iIndex==0)
        {
            break;
        }

        if (ReadFile(hReadPipe,szBuffer,MAX_PATH,&dwReturn,NULL))
        {
            szBuffer[dwReturn] = '\0';

            cout<<szBuffer<<endl;
        }
        else
        {
            if (GetLastError()==ERROR_INVALID_HANDLE)
            {
                break;
            }               
        }
    
    }

    return 0;
}


DWORD WINAPI WritePipeThread(LPVOID LPParam)
{
    HANDLE hEvent     = Context[0].hEvent;
    HANDLE hWritePipe = Context[0].hPipe;
    DWORD  dwReturn   = 0;

    char szBuffer[MAX_PATH] = {0};
    int  iIndex = 0;
    while (TRUE)
    {
        iIndex = WaitForSingleObject(hEvent,30);

        iIndex = iIndex-WAIT_OBJECT_0;

        if (iIndex==WAIT_FAILED||iIndex==0)
        {
            break;
        }

        cin>>szBuffer;   

       if (WriteFile(hWritePipe,szBuffer,strlen(szBuffer),&dwReturn,NULL))
       {

         
       }

       else
       {
           if (GetLastError()==ERROR_INVALID_HANDLE)
           {
               break;
           }   
       }
    }

    return 0;
}

进程B代码

#define WRITE_PIPE   L"\\\\.\\pipe\\ReadPipe"
#define READ_PIPE  L"\\\\.\\pipe\\WritePipe"

HANDLE hThread[2] = {0};

DWORD WINAPI  ReadPipeThread(LPARAM LPParam);
DWORD WINAPI  WritePipeThread(LPARAM LPParam);
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{


    HANDLE hReadPipe  = NULL;
    HANDLE hWritePipe = NULL;

    hThread[0] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)ReadPipeThread,NULL,0,NULL);
    hThread[1] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)WritePipeThread,NULL,0,NULL);
    
    WaitForMultipleObjects(2,hThread,TRUE,INFINITE);

    CloseHandle(hReadPipe);
    CloseHandle(hWritePipe);

    CloseHandle(hThread[0]);
    CloseHandle(hThread[1]);
    cout<<"Exit"<<endl;

    
    return -1;
}


DWORD WINAPI WritePipeThread(LPARAM LPParam)
{
    HANDLE hWritePipe = NULL;
    char  szBuffer[MAX_PATH] = {0};
    DWORD dwReturn = 0;

    while(TRUE)
    {
        hWritePipe = CreateFile(WRITE_PIPE,GENERIC_READ | GENERIC_WRITE,
            FILE_SHARE_READ | FILE_SHARE_WRITE,
            NULL,OPEN_EXISTING,0,NULL);


        if (hWritePipe==INVALID_HANDLE_VALUE)
        {
            continue;
        }

        break;
    }
    while (TRUE)
    {

        cin>>szBuffer;
        if (WriteFile(hWritePipe,szBuffer,MAX_PATH,&dwReturn,NULL))
        {
    
        }

        else
        {
            if (GetLastError()==ERROR_NO_DATA)
            {
                cout<<"Write Failed"<<endl;
                break;
            }
        }
            

    }
    return 0;
}


DWORD WINAPI  ReadPipeThread(LPARAM LPParam)
{

    HANDLE hReadPipe = NULL;
    char  szBuffer[MAX_PATH] = {0};
    DWORD dwReturn = 0;


    while(TRUE)
    {
        hReadPipe = CreateFile(READ_PIPE,GENERIC_READ | GENERIC_WRITE,
            FILE_SHARE_READ | FILE_SHARE_WRITE,
            NULL,OPEN_EXISTING,0,NULL);


        if (hReadPipe==INVALID_HANDLE_VALUE)
        {
            continue;
        }

        break;
    }
    while (TRUE)
    {
        if (ReadFile(hReadPipe,szBuffer,MAX_PATH,&dwReturn,NULL))
        {
            szBuffer[dwReturn] = '\0';
            cout<<szBuffer;
        }
        else
        {
            cout<<"Read Failed"<<endl;
            break;
        }
    
    }
    return 0;
}

*其中进程A创建了管道内核对象，以及用于读写管道的双线程。B进程通过对象名打开了A创建的内核对象，同时也创建了双线程进行命名管道的读与写。

对于管道需要多说的是有一种管道是匿名管道，也就是不需要创建对象管道的名字。那么其他进程又是如何知道这个管道对象，从而实现对信息的传递的呢？

原来它是通过内核对象的可继承性进行的，也就是说匿名管道只能作用于父子进程之间，在父进程创建子进程的时候通过对CreateProcess函数中传参，即可让子进程获得父进程的内核对象句柄。

具体实现细节，请参考《Windows核心编程》内核对象一章。

 

邮件槽

进程A代码：

#define  MAIL_SLOT_NAME  L"\\\\.\\mailslot\\Name" 

HANDLE  hReadMailSlot = INVALID_HANDLE_VALUE;
DWORD WINAPI ReadMail();
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
    int nRetCode = 0;

     
   HANDLE hReadThread = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)ReadMail,NULL,0,NULL);

    Sleep(INFINITE);

    if (hReadMailSlot!=INVALID_HANDLE_VALUE)
    {
        CloseHandle(hReadMailSlot);
    }

    Sleep(10);

    return nRetCode;
}


DWORD WINAPI ReadMail()
{

    hReadMailSlot = CreateMailslot(MAIL_SLOT_NAME,0,0,NULL);


    if (hReadMailSlot==INVALID_HANDLE_VALUE)
    {
        return -1;
    }

    //查看油槽的信息

    DWORD cbMessage = 0;
    DWORD cMessage  = 0;
    BOOL bOk  = FALSE;
    char*  szBuffer = NULL;
    DWORD  dwReturn = 0;

    while (TRUE)
    {

        bOk =  GetMailslotInfo(hReadMailSlot,NULL,&cbMessage,&cMessage,NULL);

        if (bOk==FALSE)
        {
            break;
        }

        if (cMessage==0)
        {
            continue;
        }

        else
        {
            if (szBuffer!=NULL)
            {
                free(szBuffer);

                szBuffer = NULL;
            }

            szBuffer = (char*)malloc(sizeof(char)*cbMessage+1);


            if (ReadFile(hReadMailSlot, 
                szBuffer, 
                cbMessage, 
                &dwReturn, 
                NULL)==TRUE)
            {

                szBuffer[dwReturn] = '\0';
                if (strcmp(szBuffer,"Exit")==0)
                {
                    break;
                }
            
                cout<<szBuffer<<endl;
            }        
    
        }
    }


    cout<<"ReadThread Exit"<<endl;
}

进程B代码：

#define  MAIL_SLOT_NAME  L"\\\\.\\mailslot\\Name" 
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
    int nRetCode = 0;

    HANDLE hWriteMailSlot = NULL;


    while(TRUE)
    {
        hWriteMailSlot = CreateFile(MAIL_SLOT_NAME,GENERIC_READ|GENERIC_WRITE,FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_EXISTING,
            FILE_ATTRIBUTE_NORMAL,NULL);


        if (hWriteMailSlot==INVALID_HANDLE_VALUE)
        {
            continue;
        }
        else
        {
            break;
        }

    }

    DWORD dwReturn = 0;
    char szBuffer[1024] = {0};
    while (TRUE)
    {

        cin>>szBuffer;
        if (strcmp(szBuffer,"Exit")==0)
        {
            break;
        }

        WriteFile(hWriteMailSlot,szBuffer,strlen(szBuffer),&dwReturn,NULL);

    }

    WriteFile(hWriteMailSlot,szBuffer,strlen(szBuffer),&dwReturn,NULL);
    CloseHandle(hWriteMailSlot);

    return nRetCode;
}

*邮件槽的实现和命名管道大同小异，都是A创建对象-->A写入数据-->B打开A创建的对象-->B读入数据。以前一直认为邮件槽是Windows与Linux共有的机制，自从某次上Liunx课和老师讨论了一会进程间通信的问题，

才愚蠢的知道Linux并没有邮件槽这个机制。

 

共享内存

进程A代码：

using namespace std;

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
    int nRetCode = 0;

    char szBuffer[] = "Shine";

    HANDLE hMapping = CreateFileMapping(NULL,NULL,PAGE_READWRITE,0,4096,L"ShareMemory");


    LPVOID lpBase = MapViewOfFile(hMapping,FILE_MAP_WRITE|FILE_MAP_READ,0,0,0);


    strcpy((char*)lpBase,szBuffer);


    Sleep(20000);


    UnmapViewOfFile(lpBase);

    CloseHandle(hMapping);


    return nRetCode;
}

进程B代码：

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
    int nRetCode = 0;


    HANDLE hMapping = OpenFileMapping(FILE_MAP_ALL_ACCESS,NULL,L"ShareMemory");

    if (hMapping)
    {
        wprintf(L"%s\r\n",L"Success");


        LPVOID lpBase = MapViewOfFile(hMapping,FILE_MAP_READ|FILE_MAP_WRITE,0,0,0);

        char szBuffer[20] = {0};

        strcpy(szBuffer,(char*)lpBase);


        printf("%s",szBuffer);


        UnmapViewOfFile(lpBase);

        CloseHandle(hMapping);

    }

    else
    {
        wprintf(L"%s",L"OpenMapping Error");
    }

    return nRetCode;
}

说道共享内存不得不说下内存映射：如何将一个文件映射到自己的缓冲区中。

打开文件-->计算文件大小-->创建内存映射对象Mapping-->mapofviewfile映射到自己的缓冲区中

通过文件映射来进行读写文件操作较为方便。

文件映射代码：

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
    int nRetCode = 0;

    HANDLE hFile = CreateFile(L"D:\\Demo.txt",GENERIC_READ|GENERIC_WRITE,FILE_SHARE_WRITE|FILE_SHARE_WRITE,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);

    DWORD dwHigh = 0;
    DWORD dwLow = 0;
    dwLow = GetFileSize(hFile,&dwHigh);   

    dwLow = ((dwLow + 4095)/4096)*4096;

    if (hFile==INVALID_HANDLE_VALUE)
    {

        return -1;
    }

    HANDLE hMapping = CreateFileMapping(hFile,NULL,PAGE_READWRITE,dwHigh,dwLow,NULL);

    if (hMapping==NULL)
    {
        CloseHandle(hFile);
    }
    
    char* szBuffer = NULL;

    szBuffer = (char*)MapViewOfFile(hMapping,FILE_MAP_ALL_ACCESS,0,0,0);


    if (szBuffer!=NULL)
    {
        cout<<szBuffer<<endl;
    }
    *(szBuffer+1) = 'w';


    UnmapViewOfFile(szBuffer);

    CloseHandle(hMapping);
    CloseHandle(hFile);



    return nRetCode;
}

 

消息

进程A代码：

void CServerDlg::OnBnClickedOk()
{

    CString  strBuffer;
    m_Edit.GetWindowText(strBuffer);

    if (strBuffer.GetLength()==0)
    {
        return;
    }

    COPYDATASTRUCT  Temp;

    Temp.dwData = 0;      
    Temp.cbData = strBuffer.GetLength()*sizeof(WCHAR);      //  sizeof    没有算  '\0'
    Temp.lpData = strBuffer.GetBuffer();           


    HWND hFindWindow = ::FindWindow(NULL,L"Client");

    if (hFindWindow==NULL)
    {
        return;
    }
    ::SendMessage(hFindWindow,WM_COPYDATA,NULL,(LPARAM)&Temp);

}

进程B代码

进程B需要添加WM_COPYDATA消息

BOOL CClientDlg::OnCopyData(CWnd* pWnd, COPYDATASTRUCT* pCopyDataStruct)
{
    // TODO: 在此添加消息处理程序代码和/或调用默认值
    
    if (pCopyDataStruct->lpData==NULL||pCopyDataStruct->cbData==0)
    {
        return FALSE;
    }


    int nSize = 0;                           //字节20
    int nLen = pCopyDataStruct->cbData+sizeof(WCHAR);    //字符HelloWorld10     加了个'\0'

    WCHAR* szBuffer =  new WCHAR[nLen>>1];      //   右移一位   除以二    申请  同样大的内存

    if (szBuffer==NULL)
    {
        return FALSE;
    }
    memset(szBuffer,0,sizeof(WCHAR)*(nLen>>1));

    memcpy(szBuffer,pCopyDataStruct->lpData,pCopyDataStruct->cbData);

    m_Edit.SetWindowText(szBuffer);


    delete szBuffer;

    szBuffer = NULL;

    return CDialogEx::OnCopyData(pWnd, pCopyDataStruct);
}

这种方式是由操作系统负责给目标窗口传递 ，所以目标进程必须需要窗口，不然A得不到窗口句柄就无法传递。这种方式是通过Windows消息队列传递，看起来与之前的内核对象传递消息有悖，

那是因为操作系统把相关细节都屏蔽掉了，如果深究起来还是通过Ring0的操作系统空间内核对象进行传递。

剩下的套接字，RPC，DDE等也可用来进行进程间通信，但总有种杀鸡用牛刀的感觉。我并没有再进行整理，有兴趣的可以在进行了解了解。

本文转载自：https://www.cnblogs.com/zibility/p/5657308.html

已标记关键词 清除标记
windows 进程间通信的几种方式
zhjc2012的专栏
03-04 979
http://blog.csdn.net/microzone/article/details/7044266
表情包
插入表情
还能输入1000个字符 “速评一下”
windows进程间通信
weixin_34008805的博客
12-27 67
摘 要: 随着人们对应用程序的要求越来越高，单进程应用在许多场合已不能满足人们的要求。编写多进程/多线程程序成为现代程序设计的一个重要特点，在多进程程序设计中，进程间的通信是不可避免的。Microsoft Win32 API提供了多种进程间通信的方法，全面地阐述了这些方法的特点，并加以比较和分析，希望能给读者选择通信方法提供参考。 关键词 进程 进程通信 IPC Win32 API  ...
Windows进程间各种通信方式浅谈
关注互联网安全的小虾米一枚
12-05 2万+
1 Windows进程间通信的各种方法 进程是装入内存并准备执行的程序，每个进程都有私有的虚拟地址空间，由代码、数据以及它可利用的系统资源(如文件、管道等)组成。 多进程/多线程是Windows操作系统的一个基本特征。Microsoft Win32应用编程接口(Application Programming Interface, API) 提供了大量支持应用程序间数据共享和交换的机制，这些机
Windows 进程通信的几种方式
zdy0_2004的专栏
10-20 617
Windows 进程通信的几种方式 分类： Windows 技术2011-04-08 10:11 219人阅读 评论(0) 收藏 举报 windowssockets服务器网络api分布式应用 http://blog.csdn.net/acdnjjjdjkdckjj/article/details/6308740 1 文件映射 文件映射(Memory-Mapped
国民度No.1，Python到底做了什么？
CSDN学院
01-20 2万+
毫无疑问，Python 是当下最火的编程语言之一。可以说 Python 的崛起，将编程提高了一个层次，它不再只是程序员专用，各个岗位都在学习 Python，导致普及度和国民度瞬间上升，Python 对整个行业来说都是极其有利的。 正如 TIOBE 官方评价：Python 无处不在，其实自 2018 年开始，各行各业便开始布局 Python。 在教育界， 1、自 2018 年 3 月起，在计算机二级考试加入了“Python 语言程序设计”科目； 2、2018 年，浙江省信息技术教材宣布弃用 VB 语言
windows下进程间通信的
lingxiu0613的专栏
04-16 2236
windows下进程间通信的手段有哪些？  摘 要 随着人们对应用程序的要求越来越高，单进程应用在许多场合已不能满足人们的要求。编写多进程/多线程程序成为现代程序设计的一个重要特点，在多进程程序设计中，进程间的通信是不可避免的。Microsoft Win32 API提供了多种进程间通信的方法，全面地阐述了这些方法的特点，并加以比较和分析，希望能给读者选择通信方法提供参考。 关键
Windows下进程通信的几种方式
博客搬往 http://begtostudy.cnblogs.com
03-16 1335
摘 要 随着人们对应用程序的要求越来越高，单进程应用在许多场合已不能满足人们的要求。编写多进程/多线程程序成为现代程序设计的一个重要特点，在多进程程序设计中，进程间的通信是不可避免的。Microsoft Win32 API提供了多种进程间通信的方法，全面地阐述了这些方法的特点，并加以比较和分析，希望能给读者选择通信方法提供参考。 关键词 进程 进程通信 IPC Win32
Windows进程间通信（一）
gaodezheng的专栏
04-22 978
 对于任何一个现代的操作系统，进程间通信都是其系统结构的一个重要组成部分。而说到Windows的进程(线程)间通信，那就要看是在什么意义上说了。因为正如“Windows的跨进程操作”那篇漫谈中所述，在Windows上一个进程甚至可以“打开”另一个进程，并在对方的用户空间分配内存、再把程序或数据拷贝过去，最后还可以在目标进程中创建一个线程、让它为所欲为。显然，这已经不只是进程间的“通信”，而是进程间
进程间通信
xgbing
08-23 7572
摘 要 随着人们对应用程序的要求越来越高，单进程应用在许多场合已不能满足人们的要求。编写多进程/多线程程序成为现代程序设计的一个重要特点，在多进程程序设计中，进程间的通信是不可避免的。Microsoft Win32 API提供了多种进程间通信的方法，全面地阐述了这些方法的特点，并加以比较和分析，希望能给读者选择通信方法提供参考。1 进程与进程通信 　　进程是装入内存并准备执行的程序，每个进
Android通信详解
yangxun0727l的博客
06-08 287
Android通信分类 线程间通信 进程间通信 线程和进程间的通信 网络通信 一、线程间通信1、runOnUiThread(Runnable) 在子线程中直接使用该方法，可以更新UIrunOnUiThread(new Runnable(){//更新UI @Override public void
几种常见进程间通信（IPC）方式之信号
Lyn&Xx
12-04 1039
几种常见进程间通信（IPC）方式-信号 前言 进程间通信是指在不同进程之间传播或交换信息，在Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间，进程之间不能相互访问。必须通过内核才能进行数据交换。如图： 常见的通信方式有以下几种： 管道pipe 有名管道FIFO 消息队列MessageQueue 共享存储 信号量Semaphore 信号Signal 套接字Socket ...
多核时代：并行程序设计探讨（4）——Windows和Linux对决(进程间通信)
华仔-技术博客
08-04 6500
                             进程间通信多进程和多线程本质上就是将原来一个进程或者线程处理的任务分给了多个进程或者线程，也可以说是将原来一个CPU处理的任务分给了多个CPU处理，类似于随着生产力的发展，原来一个人包打天下的个人英雄主义时代被分工合作的团队取代一样。既然是一个团队，就必然涉及到分工合作问题，并行程序的设计本质上就是解决“分工”和“合作”的问题。其中
[转]进程间通信的方式及比较
weixin_30477293的博客
02-18 50
进程间通信就是在不同进程之间传播或交换信息，那么不同进程之间存在着什么双方都可以访问的介质呢？进程的用户空间是互相独立的，一般而言是不能互相访问的，唯一的例外是共享内存区。但是，系统空间却是“公共场所”，所以内核显然可以提供这样的条件。除此以外，那就是双方都可以访问的外设了。在这个意义上，两个进程当然也可以通过磁盘上的普通文件交换信息，或者通过“注册表”或其它数据库中的某些表项和记录交换信息。广义...
进程间通信的几种方式浅谈
RTC hacker
11-29 1680
<br />程序员必须让拥有依赖关系的进程集协调，这样才能达到进程的共同目标。可以使用两种技术来达到协调。第一种技术在具有通信依赖关系的两个进程间传递信息。这种技术称做进程间通信（interprocess communication）。第二种技术是同步，当进程间相互具有合作依赖时使用。这两种类型的依赖关系可以同时存在。<br />一般而言，进程有单独的地址空间。我们可以了解下可执行程序被装载到内存后建立的一系列映射等理解这一点。如此以来意味着如果我们有两个进程（进程A和进程B），那么，在进程A中声明的数据对
C语言入门--必须基础17讲
07-28
适合没有基础的人群学习C语言，简单的入门教程。帮助小白理解什么是开发，什么是编程。做的很简单，很多细节没有详细讲解，不适合用来深入研究。学了这个，你能理解什么是编程，什么是C语言。
Vue基本指令
溪斜山遮的博客
01-21 3324
Vue基本指令      Vue基本模板语法      Vue绑定类样式和内联样式      条件渲染指令      事件绑定 Vue基本模板语法     1. 文本插值 使用双大括号{{}} 表示 使用v-once指令实现 使用v-text指令实现  &nbsp
©️2020 CSDN 皮肤主题: Age of Ai 设计师:meimeiellie 返回首页