进程

程序是计算机指令的集合，它以文件的形式存储在磁盘上。

进程通常上被定义为一个正在运行的程序的实例，是一个程序在其自身的地址空间中的一次执行活动，一个程序可以对应多个进程。

进程是资源申请，高度和独立运行的单位，因此，它使用系统中的运行资源，而程序不能申请使用系统资源，不能被系统高度也不能作为独立运行的单位，因此它不占系统运行资源。

进程的组成

操作系统用来管理进行的内核对象

内核对象也是系统用来存放关于进程的统计信息的地方，内核对象是操作系统内部分配的一个内在块，该内存块是一种数据结构，其成员负责维护该对象的各种信息。

地址空间

它包含所有可执行模块或DLL模块的代码和数据，另外，它也包含动态内存分配的地址空间，例如线程的栈和堆分配空间。

进程从来不执行任何东西，它只是纯粹的容器，或说是线程的执行环境。

若要使它完成某项操作，它必须拥有一个在它环境中运行的的线程，次线程负责执行包含在进程的地址空间中的代码，也就是，真正完成代码执行的线程。

子进程

子进程还是一个进程，指的是由另一个进程(对应称之为父进程)所创建的进程。

单任务的同步机制——线程、子进程都可以实现。

需要保护地址空间。

子进程的线程既可以在父进程终止之后执行代码，也可以在父进程运行的过程中执行代码。

创建进程

CreateProcessW

CreateProcess函数
CreateProcessW(
    _In_opt_ LPCWSTR lpApplicationName,// 该字符串可以指定要执行的模块的完整路径和文件名
    _Inout_opt_ LPWSTR lpCommandLine,  //命令行

    _In_opt_ LPSECURITY_ATTRIBUTES lpProcessAttributes,
//该 结构确定子进程是否可以继承返回到新进程对象的句柄。如果//lpProcessAttributes为NULL，则不能继承该句柄
    _In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes,
//该结构确定子进程是否可以继承返回到新线程对象的句柄。如果//lpThreadAttributes为NULL，则不能继承该句柄
    _In_ BOOL bInheritHandles,
//如果此参数为TRUE，则新进程将继承调用进程中的每个可继承句柄。如果参//数为FALSE，则不会继承句柄。请注意，继承的句柄与原始句柄具有相同的值和//访问权限
    _In_ DWORD dwCreationFlags,// 控制优先级类别和流程创建的标志 CREATE_NEW_CONSOLE
    _In_opt_ LPVOID lpEnvironment,// 指向新进程的环境块的指针。如果此参数为//NULL，则新进程将使用调用进程的环境
//
    _In_opt_ LPCWSTR lpCurrentDirectory,// 进程当前目录的完整路径
    _In_ LPSTARTUPINFOW lpStartupInfo, //设置扩展属性
    _Out_ LPPROCESS_INFORMATION lpProcessInformation // 该结构接收有关新进程的标识//信息
    );

示例:创建一个用firefox打开bing的进程。

#include<stdio.h>
#include<tchar.h>
#include<windows.h>
void RunExe()
{
    //TCHAR szApplicationName[] = _T("D:\\Mozilla Firefox\\firefox.exe");
    TCHAR szlpCommandLine[] = _T("\"D:\\Mozilla Firefox\\firefox.exe\"https://cn.bing.com/");
    STARTUPINFO strStartupInfo;
    memset(&strStartupInfo,0,sizeof(strStartupInfo));
    strStartupInfo.cb = sizeof(strStartupInfo);
    PROCESS_INFORMATION szProcessInformation;
    memset(&szProcessInformation,0,sizeof(szProcessInformation));
    int iRet = CreateProcess(NULL, szlpCommandLine, NULL, NULL, false,CREATE_NEW_CONSOLE,NULL,NULL,&strStartupInfo,&szProcessInformation);

    if (iRet)
    {
        //创建成功
        WaitForSingleObject(szProcessInformation.hProcess,3000);
        CloseHandle(szProcessInformation.hProcess);
        CloseHandle(szProcessInformation.hThread);
        szProcessInformation.dwProcessId = 0;
        szProcessInformation.dwThreadId = 0;
        szProcessInformation.hThread = 0;
        szProcessInformation.hProcess = 0;
        printf_s("Success iRet = %d\n",iRet);

    }
    else
    {
        printf_s("Create Failed iRet = %d,errorcode =%d\n",iRet,GetLastError());
    }

}
int main(void)
{

    printf("test\n");
    RunExe();
    system("pause");
    return 0;
}

进程间的通信方式

socket编程——IP和端口
剪贴板——剪贴板的内核对象
邮槽——邮槽的内核对象
匿名管道——内核对象
命名管道——内核对象
Copy_data findwindows wm_copydata——消息sendmessage

剪贴板

系统维护管理的一块内存区域。

原理:当一个进程在复制数据时，是将数据放到内存区域中，当另一个进程在粘贴数据时，从该内存区域取出数据，显示到窗口上面。

示例:

void CClipboardDlg::OnBnClickedButton2()//发送
{
    // 1 打开剪切板
    if (OpenClipboard())
    {
        //2 清空剪切板
        EmptyClipboard();
        char* szSendBuf;
        //3 获取编辑框的内容
        CStringW strSendW;
        GetDlgItemText(IDC_EDIT_SEND, strSendW);

        CStringA strSend = (CStringA)strSendW;

        //4 分配一个内存对象，内存对象的句柄就是hClip
        HANDLE hClip = GlobalAlloc(GMEM_MOVEABLE, strSend.GetLength() + 1);
        //5 将剪切板句柄加锁
        szSendBuf = (char*)GlobalLock(hClip);
        strcpy(szSendBuf, strSend);
        TRACE("szSendBuf = %s", szSendBuf);
        GlobalUnlock(hClip);
        //6 将数据放入剪切板
        SetClipboardData(CF_TEXT, hClip);
        //关闭剪切板
        CloseClipboard();
    }

}


void CClipboardDlg::OnBnClickedButton3()//接收
{
    if (OpenClipboard())
    {
        //确认剪切板是否可用
        if (IsClipboardFormatAvailable(CF_TEXT))
        {
            HANDLE hClip;
            char* pBuf;
            //向剪切板要数据
            hClip = GetClipboardData(CF_TEXT);
            pBuf = (char*)GlobalLock(hClip);
            USES_CONVERSION;
            LPCWSTR strBuf = A2W(pBuf);
            GlobalUnlock(hClip);
            SetDlgItemText(IDC_EDIT_RECV, strBuf);
        }
        CloseClipboard();
    }

}

邮槽

使用邮槽通信的进程分为服务端和客户端。邮槽有服务端创建，在创建时需要指定邮槽名，创建之后服务端得到邮槽的句柄。在邮槽创建后，客户端可以通过邮槽名的打开邮槽，在获得句柄后可以向邮槽写入消息。

邮槽通信是单向的，只有服务端才能从邮槽中读取消息，客户端只能写入消息。消息是先入先出的。客户端先写入的消息在服务端先被读取。

通过邮槽通信的数据可以是任意格式的，但是一条消息不能大于424字节。

邮槽除了在本机内进程进程间通信外，在主机间也可以通信。在主机间进程邮槽通信时，数据通过网络传播时使用的是数据包协议(UDP),所以是一种不可靠通信。通过网络进程邮槽通信时，客户端必须知道服务端的主机名或域名。

示例:

服务端

void CChildView::OnSlot()
{

    //    "\\\\.\\mailslot\\Mymailslot    \\.\mailslot\Mymailslot 
    //  1  创建一个邮槽
    LPCTSTR szSlotName = TEXT("\\\\.\\mailslot\\Mymailslot");
    HANDLE hSlot = CreateMailslot(szSlotName,
        0,                             // no maximum message size 
        MAILSLOT_WAIT_FOREVER,         // no time-out for operations 
        NULL); // default security

    if (hSlot == INVALID_HANDLE_VALUE)
    {
        TRACE("CreateMailslot failed with %d\n", GetLastError());
        return;
    }
    // 2 读取数据
    char szBuf[100] = { 0 };
    DWORD dwRead;
    TRACE("Begin ReadFile");
    if (!ReadFile(hSlot, szBuf, 100, &dwRead, NULL))
    {
        MessageBox(_T("读取数据失败"));
        CloseHandle(hSlot);
        return;
    }
    TRACE("End ReadFile");
    MessageBox((CStringW)szBuf);
    CloseHandle(hSlot);
     
}

客户端

void CChildView::OnSend()
{
    //创建一个文件句柄
    LPCTSTR szSlotName = TEXT("\\\\.\\mailslot\\Mymailslot");
    HANDLE    hMailSlot = CreateFile(szSlotName,FILE_GENERIC_WRITE,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
    if (hMailSlot == INVALID_HANDLE_VALUE)
    {
        TRACE("CreateMail fail with %d\n",GetLastError());
        return;
    }
    //写入数据
    char szBuf[] = "ZYX is handsome";
    DWORD dwWrite;
    if (!WriteFile(hMailSlot,szBuf,strlen(szBuf)+1,&dwWrite,NULL))
    {
        MessageBox(_T("写入数据失败"));
        CloseHandle(hMailSlot);
        return;
    }
    CloseHandle(hMailSlot);
}

匿名管道

匿名管道是一个没有命名的单向管道，本质上就是一个共享的内存，抽象成是管道。

通常用来在父进程和子进程之间通信。只能实现本地两个进程之间的通信。不能实现网络通信。

优点是效率高，原理本质上就是共享内存。

CreatePipe

CreatePipe(
    _Out_ PHANDLE hReadPipe,  //该变量接收管道的读取句柄
    _Out_ PHANDLE hWritePipe,// 该变量接收管道的写句柄
    _In_opt_ LPSECURITY_ATTRIBUTES lpPipeAttributes,//安全属性NULL-句柄是否能被子进程继承
    _In_ DWORD nSize  //管道缓冲区的大小 0 :默认缓冲区大小
);

命名管道

与Socket相似，支持网络之间进程的通信。

CreateNamePipe

HANDLE CreateNamedPipeA(
  LPCSTR                lpName,  // \.\pipe<i>pipename
  DWORD                 dwOpenMode,
  DWORD                 dwPipeMode,
  DWORD                 nMaxInstances,
  DWORD                 nOutBufferSize,
  DWORD                 nInBufferSize,
  DWORD                 nDefaultTimeOut,
  LPSECURITY_ATTRIBUTES lpSecurityAttributes
);

ConnectNamePipe

BOOL ConnectNamedPipe(
  HANDLE       hNamedPipe,
  LPOVERLAPPED lpOverlapped
);

示例:
服务端

void CChildView::OnCreateNamePipe()
{
    //1创建一个命名管道
    LPCTSTR szhPipeName = TEXT("\\\\.\\pipe\\mypipe");
    hNamedPipe = CreateNamedPipe(szhPipeName, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, PIPE_TYPE_BYTE, 1, 1024, 1024, 0, NULL);
    if (hNamedPipe == INVALID_HANDLE_VALUE)
    {
        TRACE("CreateNamedPipe failed with %d\n", GetLastError());
        MessageBox(_T("创建命名管道失败"));
        return;
    }
    //2等待客户端的连接
    HANDLE hEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
    if (hEvent == NULL)
    { 
        MessageBox(_T("创建事件失败"));
        CloseHandle(hNamedPipe);
        hNamedPipe = NULL;
        return;
    }
    OVERLAPPED ovlap;
    ZeroMemory(&ovlap,sizeof(OVERLAPPED));
    ovlap.hEvent = hEvent;
    if (!ConnectNamedPipe(hNamedPipe, &ovlap))
    {
        if(GetLastError() != ERROR_IO_PENDING)
        {
            MessageBox(_T("等待客户端连接失败"));
            CloseHandle(hNamedPipe);
            CloseHandle(hEvent);
            hNamedPipe = NULL;
            hEvent = NULL;
            return;
        }
    }
    if (WaitForSingleObject(hEvent, INFINITE) == WAIT_FAILED)
    {
        MessageBox(_T("等待对象失败"));
        CloseHandle(hNamedPipe);
        CloseHandle(hEvent);
        hNamedPipe = NULL;
        hEvent = NULL;
        return;
    }
}


void CChildView::OnSreadNamePipe()
{
    //读取数据
    char szBuf[100] = { 0 };
    DWORD dwRead;
    if (!ReadFile(hNamedPipe, szBuf, 100, &dwRead, NULL))
    {
        MessageBox(_T("读取数据失败"));
        return;
    }
    MessageBox((CStringW)szBuf);
}

void CChildView::OnSwriteNamePipe()
{
    //写入数据
    char szBuf[] = "ZYX is handsome Server";
    DWORD dwWrite;
    if (!WriteFile(hNamedPipe, szBuf, strlen(szBuf) + 1, &dwWrite, NULL))
    {
        MessageBox(_T("写入数据失败"));
        return;
    } 
}

客户端

void CChildView::OnConNamePipe()
{
    LPCTSTR szNamePipeName = TEXT("\\\\.\\pipe\\mypipe");

    if (WaitNamedPipe(szNamePipeName, NMPWAIT_WAIT_FOREVER) == 0)
    {
        MessageBox(_T("当前没有可以利用的管道"));
        return;
    }
    hNamedPipe = CreateFile(szNamePipeName,GENERIC_READ | GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
    if (hNamedPipe == INVALID_HANDLE_VALUE)
    {
        MessageBox(_T("打开命名管道失败!"));
        hNamedPipe = NULL;
        return;
    }
    
}


void CChildView::OnReadNamePipe()
{
    //读取数据
    char szBuf[100] = { 0 };
    DWORD dwRead;
    if (!ReadFile(hNamedPipe, szBuf, 100, &dwRead, NULL))
    {
        MessageBox(_T("读取数据失败"));
        return;
    }
    MessageBox((CStringW)szBuf);
}


void CChildView::OnWriteNamePipe()
{
    // TODO: 在此添加命令处理程序代码
        //写入数据
    char szBuf[] = "ZYX is handsome Client";
    DWORD dwWrite;
    if (!WriteFile(hNamedPipe, szBuf, strlen(szBuf) + 1, &dwWrite, NULL))
    {
        MessageBox(_T("写入数据失败"));
        CloseHandle(hNamedPipe);
        return;
    }
    CloseHandle(hNamedPipe);
}

WM_COPYDATA

利用WM_COPYDATA这个消息进行通信。

是最常用、最灵活的进程间通信方式。

一个应用程序发送WM_COPYDATA消息以将数据传递给另一个应用程序。

SPY++专门够用来查找窗口句柄。

要给进程发送数据，首先要拿到该窗口的句柄，也就是要拿到标题(因为句柄有可能会发生变化)。

发送端:

void CWMCOPYDATASENDDlg::OnBnClickedSend()
{
    //必须要知道接收端的标题 句柄 spy工具
    CString strWindowTitle = _T("MFCRecv");
    CString strDataToSend = _T("Hello");
    //获取句柄
    HWND hRecvWnd = ::FindWindow(NULL, strWindowTitle.GetBuffer(0));
    if (hRecvWnd != NULL && ::IsWindow(hRecvWnd))
    {
        //数据的封装
        COPYDATASTRUCT cpd;
        cpd.dwData = 0;
        cpd.cbData = strDataToSend.GetLength()*sizeof(TCHAR);
        cpd.lpData = (PVOID)strDataToSend.GetBuffer(0);
        ::SendMessage(hRecvWnd,WM_COPYDATA,(WPARAM)(AfxGetApp()->m_pMainWnd),(LPARAM)&cpd);
    }
    strDataToSend.ReleaseBuffer();
}

接收端：

BOOL CWMCOPYDATADlg::OnCopyData(CWnd* pWnd, COPYDATASTRUCT* pCopyDataStruct)
{
    //消息响应函数
    //解析数据
    LPCTSTR szText = (LPCTSTR)(pCopyDataStruct->lpData);
    DWORD dwLength = pCopyDataStruct->cbData;
    TCHAR szRecvText[1024] = { 0 };
    memcpy(szRecvText,szText,dwLength);
    MessageBox(szRecvText, _T("Bingo"), MB_OK);
    return CDialogEx::OnCopyData(pWnd, pCopyDataStruct);
}

比较&总结

剪贴板比较简单，剪贴板和匿名管道只能实现同一机器的两个进程通信。而不能实现网络进程之间的通信。
邮槽是基于广播的，可以一对多发送。但只能一个发送，一个接收(单向)。
命名管道和邮槽可以进程网络通信。命名管道只能是点对点的单一通信。
邮槽的缺点就是传输的数据量很小，424字节以下。
WM_COPYDATA封装数据非常方便，如果数据量较大，建议使用命名管道。

【操作系统】进程间的通信

进程

进程的组成

子进程

创建进程

进程间的通信方式

剪贴板

邮槽

匿名管道

命名管道

WM_COPYDATA

比较&总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【操作系统】进程间的通信

进程

进程的组成

子进程

创建进程

进程间的通信方式

剪贴板

邮槽

匿名管道

命名管道

WM_COPYDATA

比较&总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像