进程

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

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

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

进程的组成

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

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

地址空间

它包含所有可执行模块或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

比较&总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景