几种Windows进程通信

2020-01-06 16:25:03 160 收藏 1
分类专栏： windows c/c++ 文章标签： 进程通信
原文链接：https://www.cnblogs.com/zibility/p/5657308.html
版权
windows c/c++ 专栏收录该内容
272 篇文章 4 订阅
订阅专栏

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

小哈龙
关注
  • 0
    点赞
  • 0
    评论
  • 1
    收藏
  • 一键三连
    一键三连

  • 扫一扫，分享海报

专栏目录
Windows 进程通信的几种方式
C++ 永无止境
04-08 1163
<br />1 文件映射<br />文件映射(Memory-Mapped Files)能使进程把文件内容当作进程地址区间一块内存那样来对待。因此，进程不必使用文件I/O操作，只需简单的指针操作就可读取和修改文件的内容。<br />Win32 API允许多个进程访问同一文件映射对象，各个进程在它自己的地址空间里接收内存的指针。通过使用这些指针，不同进程就可以读或修改文件的内容，实现了对文件中数据的共享。<br />应用程序有三种方法来使多个进程共享一个文件映射对象。<br />(1)继承：第一个进程建立文件映
Windows下进程通信的几种方式
博客搬往 http://begtostudy.cnblogs.com
03-16 1361
摘 要 随着人们对应用程序的要求越来越高，单进程应用在许多场合已不能满足人们的要求。编写多进程/多线程程序成为现代程序设计的一个重要特点，在多进程程序设计中，进程间的通信是不可避免的。Microsoft Win32 API提供了多种进程间通信的方法，全面地阐述了这些方法的特点，并加以比较和分析，希望能给读者选择通信方法提供参考。 关键词 进程 进程通信 IPC Win32
表情包
插入表情
还能输入1000个字符
相关推荐
windows下进程间通信的
lingxiu0613的专栏
04-16 2370
windows下进程间通信的手段有哪些？  摘 要 随着人们对应用程序的要求越来越高，单进程应用在许多场合已不能满足人们的要求。编写多进程/多线程程序成为现代程序设计的一个重要特点，在多进程程序设计中，进程间的通信是不可避免的。Microsoft Win32 API提供了多种进程间通信的方法，全面地阐述了这些方法的特点，并加以比较和分析，希望能给读者选择通信方法提供参考。 关键
windows 进程间通信的几种方式
zhjc2012的专栏
03-04 994
http://blog.csdn.net/microzone/article/details/7044266
windows进程间通信
liuyinghui523的专栏
10-24 2591
摘 要: 随着人们对应用程序的要求越来越高，单进程应用在许多场合已不能满足人们的要求。编写多进程/多线程程序成为现代程序设计的一个重要特点，在多进程程序设计中，进程间的通信是不可避免的。Microsoft Win32 API提供了多种进程间通信的方法，全面地阐述了这些方法的特点，并加以比较和分析，希望能给读者选择通信方法提供参考。 关键词 进程 进程通信 IPC Win32 API 
进程间通信
xgbing
08-23 7613
摘 要 随着人们对应用程序的要求越来越高，单进程应用在许多场合已不能满足人们的要求。编写多进程/多线程程序成为现代程序设计的一个重要特点，在多进程程序设计中，进程间的通信是不可避免的。Microsoft Win32 API提供了多种进程间通信的方法，全面地阐述了这些方法的特点，并加以比较和分析，希望能给读者选择通信方法提供参考。1 进程与进程通信 　　进程是装入内存并准备执行的程序，每个进
windows下进程间通信的手段有哪些？
maplele
03-04 1702
作者：李志刚 纪玉波 程小茁 崔朝辉摘 要 随着人们对应用程序的要求越来越高，单进程应用在许多场合已不能满足人们的要求。编写多进程/多线程程序成为现代程序设计的一个重要特点，在多进程程序设计中，进程间的通信是不可避免的。Microsoft Win32 API提供了多种进程间通信的方法，全面地阐述了这些方法的特点，并加以比较和分析，希望能给读者选择通信方法提供参考。关键词 进程 进程通信 IPC
C#进程间通信的几种方式：管道通信
dnazhd的博客
01-18 1万+
年底了，有了大把时间，终于着手尝试写写技术博客，跟大家交流下心得。 就从进程间通信相关的内容开始吧，在此对以往工作中用到的几种进程间通信方式做一下简单的总结。 进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。进程间通信的方式（C/S结构开发环境）通常有管道、Socket、消息队列、信号量、共享存储、Streams等。 方式一：管道通...
Windows进程通信之进程内存读写
danny的记事本
08-07 1546
本文由danny发表于 http://blog.csdn.net/danny_share
【资料】linux进程间通信的方式
weixin_30687587的博客
10-19 116
【资料】linux进程间通信的方式 # 管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。 # 有名管道 (named pipe) ： 有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。 # 信号量( semophore ) ： 信号...
Windows进程间各种通信方式浅谈
关注互联网安全的小虾米一枚
12-05 2万+
1 Windows进程间通信的各种方法 进程是装入内存并准备执行的程序，每个进程都有私有的虚拟地址空间，由代码、数据以及它可利用的系统资源(如文件、管道等)组成。 多进程/多线程是Windows操作系统的一个基本特征。Microsoft Win32应用编程接口(Application Programming Interface, API) 提供了大量支持应用程序间数据共享和交换的机制，这些机
多核时代：并行程序设计探讨（4）——Windows和Linux对决(进程间通信)
华仔-技术博客
08-04 6575
                             进程间通信多进程和多线程本质上就是将原来一个进程或者线程处理的任务分给了多个进程或者线程，也可以说是将原来一个CPU处理的任务分给了多个CPU处理，类似于随着生产力的发展，原来一个人包打天下的个人英雄主义时代被分工合作的团队取代一样。既然是一个团队，就必然涉及到分工合作问题，并行程序的设计本质上就是解决“分工”和“合作”的问题。其中
Windows进程间通信
Guo_guo
01-16 1万+
因为Windows中每个进程都有自己的虚拟地址空间，所以一个进程无法访问到别一个进程的地址空间，因此相对来说进程间的通信要复杂一些。Windows操作系统为应用程序之间的进程间通信，数据共享提供了很多机制，称为interprocess communications (IPC)。其中一些机制可以用来在同一台计算机内不同进程之间通信，一些可以在网络中不同计算机上运行的进程之间进行通信。    典型的
Android通信详解
yangxun0727l的博客
06-08 347
Android通信分类 线程间通信 进程间通信 线程和进程间的通信 网络通信 一、线程间通信1、runOnUiThread(Runnable) 在子线程中直接使用该方法，可以更新UIrunOnUiThread(new Runnable(){//更新UI @Override public void
pytorch实现前馈神经网络实验（torch实现）
10-31
pytorch实现前馈神经网络实验（torch实现）参考链接：https://blog.csdn.net/qq_37534947/article/details/109402126
HoloLens2开发入门教程
05-01
本课程为HoloLens2开发入门教程，讲解<span>部署</span>开发环境，安装VS2019，Unity版本，Windows SDK，<span>创建Unity项目，</span>讲解如何使用MRTK，编辑器模拟手势交互，打包VS工程并编译部署应用到HoloLens上等。
被女朋友逼着学编程很崩溃？10个边玩游戏边学编程的网站了解一下！（含Python）
qq_34447215的博客
07-30 1486
大家好，我是阿玺。 最近技术交流群里又来了一些新伙伴，除了日常的技术交流之外，还吃到了一些瓜~（不要怀疑，我们是正经的技术学习群） 群里有个小伙伴小智就给大家分享了他的故事。 小智本来是从事一份网站推广的工作，工资说高不高，说少不少，在一个省会城市混了两三年，也能拿个4到5K。照理说也还是能够正常过生活的，可惜他有个不知满足的女朋友。 整天就是在他耳边念叨“我闺蜜男朋友怎样怎样”，要不就是“我就应该找个更有钱的”，“你就不知道上进吗？”然后给他科普做程序员工资多高，一万多一个月，逼他转行学编程.
JavaScript学习（八十八）—数组知识点总结，超详细！！！
m0_46374969的博客
07-24 7567
JavaScript学习（八十八）—数组知识点总结，超详细！！！ 每天进步一点点 一、数组的概念 数组可以把一组相关的数据一起存放，并提供方便的访问(获取）方式。 数组是指一组数据的集合，其中的每个数据被称作元素，在数组中可以存放任意类型的元素。数组是一种将一组数据存储在单个变量名下的优雅方式。 二、创建数组 //创建数组 var 数组名 = new Array(); var arr=new Array();创建一个空数组 三、数组的索引 索引(下标)：用来访问数组
©️2020 CSDN 皮肤主题: Age of Ai 设计师:meimeiellie 返回首页
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值