進程間通訊

時間  2019-11-29
標籤 進程 通訊 简体版
原文   原文鏈接

1 進程與進程通訊ios

　　進程是裝入內存並準備執行的程序，每一個進程都有私有的虛擬地址空間，由代碼、數據以及它可利用的系統資源(如文件、管道等)組成。多進程/多線程是Windows操做系統的一個基本特徵。Microsoft Win32應用編程接口(Application Programming Interface, API)提供了大量支持應用程序間數據共享和交換的機制，這些機制行使的活動稱爲進程間通訊(InterProcess Communication, IPC)，進程通訊就是指不一樣進程間進行數據共享和數據交換。
　　正由於使用Win32 API進行進程通訊方式有多種，如何選擇恰當的通訊方式就成爲應用開發中的一個重要問題，下面本文將對Win32中進程通訊的幾種方法加以分析和比較。程序員

2 進程通訊方法編程

2.1 文件映射
　　文件映射(Memory-Mapped Files)能使進程把文件內容看成進程地址區間一塊內存那樣來對待。所以，進程沒必要使用文件I/O操做，只需簡單的指針操做就可讀取和修改文件的內容。
　　Win32 API容許多個進程訪問同一文件映射對象，各個進程在它本身的地址空間裏接收內存的指針。經過使用這些指針，不一樣進程就能夠讀或修改文件的內容，實現了對文件中數據的共享。
　　應用程序有三種方法來使多個進程共享一個文件映射對象。
　　(1)繼承：第一個進程創建文件映射對象，它的子進程繼承該對象的句柄。
　　(2)命名文件映射：第一個進程在創建文件映射對象時能夠給該對象指定一個名字(可與文件名不一樣)。第二個進程可經過這個名字打開此文件映射對象。另外，第一個進程也能夠經過一些其它IPC機制(有名管道、郵件槽等)把名字傳給第二個進程。
　　(3)句柄複製：第一個進程創建文件映射對象，而後經過其它IPC機制(有名管道、郵件槽等)把對象句柄傳遞給第二個進程。第二個進程複製該句柄就取得對該文件映射對象的訪問權限。
　　文件映射是在多個進程間共享數據的很是有效方法，有較好的安全性。但文件映射只能用於本地機器的進程之間，不能用於網絡中，而開發者還必須控制進程間的同步。windows

#include <windows.h>
#include <iostream>

using namespace std;

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

    HANDLE hFile = CreateFile("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);


    system("pause");
    return nRetCode;
}


2.2 共享內存
　　Win32 API中共享內存(Shared Memory)實際就是文件映射的一種特殊狀況。進程在建立文件映射對象時用0xFFFFFFFF來代替文件句柄(HANDLE)，就表示了對應的文件映射對象是從操做系統頁面文件訪問內存，其它進程打開該文件映射對象就能夠訪問該內存塊。因爲共享內存是用文件映射實現的，因此它也有較好的安全性，也只能運行於同一計算機上的進程之間。安全

#define   _CRT_SECURE_NO_WARNINGS

#include <windows.h>
#include <iostream>

using namespace std;

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

    char szBuffer[] = "ONDragon";

    HANDLE hMapping = CreateFileMapping(NULL, NULL, PAGE_READWRITE, 0, 4096, "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;
}
#define   _CRT_SECURE_NO_WARNINGS

#include <windows.h>
#include <iostream>

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


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

    if (hMapping)
    {
        wprintf(L"%s\r\n", "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", "OpenMapping Error");
    }

    return nRetCode;
}

2.3 匿名管道
　　管道(Pipe)是一種具備兩個端點的通訊通道：有一端句柄的進程能夠和有另外一端句柄的進程通訊。管道能夠是單向－一端是隻讀的，另外一端點是隻寫的；也能夠是雙向的一管道的兩端點既可讀也可寫。
　　匿名管道(Anonymous Pipe)是 在父進程和子進程之間，或同一父進程的兩個子進程之間傳輸數據的無名字的單向管道。一般由父進程建立管道，而後由要通訊的子進程繼承通道的讀端點句柄或寫 端點句柄，而後實現通訊。父進程還能夠創建兩個或更多個繼承匿名管道讀和寫句柄的子進程。這些子進程可使用管道直接通訊，不須要經過父進程。
　　匿名管道是單機上實現子進程標準I/O重定向的有效方法，它不能在網上使用，也不能用於兩個不相關的進程之間。
2.4 命名管道
　　命名管道(Named Pipe)是服務器進程和一個或多個客戶進程之間通訊的單向或雙向管道。不一樣於匿名管道的是命名管道能夠在不相關的進程之間和不一樣計算機之間使用，服務器創建命名管道時給它指定一個名字，任何進程均可以經過該名字打開管道的另外一端，根據給定的權限和服務器進程通訊。
　　命名管道提供了相對簡單的編程接口，使經過網絡傳輸數據並不比同一計算機上兩進程之間通訊更困難，不過若是要同時和多個進程通訊它就力不從心了。服務器

#include <windows.h>
#include <iostream>

using namespace std;

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

#define Log(str) {{printf("%s\n",str);}}

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 main(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;

    //Create A Named Pipe
    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;
}


//Write Pipe
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))
        {
            Log("WritePipe Successful");
        }

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

    return 0;
}
#include <windows.h>
#include <iostream>

using namespace std;

//pipe name
#define WRITE_PIPE        "\\\\.\\pipe\\ReadPipe"
#define READ_PIPE        "\\\\.\\pipe\\WritePipe"

//thread array
HANDLE hThread[2] = { 0 };

//pipe function
DWORD WINAPI  ReadPipeThread(LPARAM LPParam);
DWORD WINAPI  WritePipeThread(LPARAM LPParam);

int main(int argc, TCHAR* argv[], TCHAR* envp[])
{
    HANDLE hReadPipe = NULL;
    HANDLE hWritePipe = NULL;

    //Create Thread About Pipe
    hThread[0] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ReadPipeThread, NULL, 0, NULL);
    hThread[1] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)WritePipeThread, NULL, 0, NULL);

    //Wait 
    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)
    {
        //CreatePipe
        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)
    {
        //CreatePipe
        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;
}

2.5 郵件槽
　　郵件槽(Mailslots)提 供進程間單向通訊能力，任何進程都能創建郵件槽成爲郵件槽服務器。其它進程，稱爲郵件槽客戶，能夠經過郵件槽的名字給郵件槽服務器進程發送消息。進來的消 息一直放在郵件槽中，直到服務器進程讀取它爲止。一個進程既能夠是郵件槽服務器也能夠是郵件槽客戶，所以可創建多個郵件槽實現進程間的雙向通訊。
　　經過郵件槽能夠給本地計算機上的郵件槽、其它計算機上的郵件槽或指定網絡區域中全部計算機上有一樣名字的郵件槽發送消息。廣播通訊的消息長度不能超過400字節，非廣播消息的長度則受郵件槽服務器指定的最大消息長度的限制。
　　郵件槽與命名管道類似，不過它傳輸數據是經過不可靠的數據報(如TCP/IP協議中的UDP包)完成的，一旦網絡發生錯誤則沒法保證消息正確地接收，而命名管道傳輸數據則是創建在可靠鏈接基礎上的。不過郵件槽有簡化的編程接口和給指定網絡區域內的全部計算機廣播消息的能力，因此郵件槽不失爲應用程序發送和接收消息的另外一種選擇。網絡

#include <windows.h>
#include <iostream>

using namespace std;

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

HANDLE  hReadMailSlot = INVALID_HANDLE_VALUE;
DWORD WINAPI ReadMail();

int main(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;
}
#include <windows.h>
#include <iostream>

using namespace std;

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

int main(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;
}

2.6 剪貼板
　　剪貼板(Clipped Board)實質是Win32 API中一組用來傳輸數據的函數和消息，爲Windows應用程序之間進行數據共享提供了一箇中介，Windows已創建的剪切(複製)－粘貼的機制爲不一樣應用程序之間共享不一樣格式數據提供了一條捷徑。當用戶在應用程序中執行剪切或複製操做時，應用程序把選取的數據用一種或多種格式放在剪貼板上。而後任何其它應用程序均可以從剪貼板上拾取數據，從給定格式中選擇適合本身的格式。
　　剪貼板是一個很是鬆散的交換媒介，能夠支持任何數據格式，每一格式由一無符號整數標識，對標準(預約義)剪貼板格式，該值是Win32 API定義的常量；對非標準格式可使用Register Clipboard Format函數註冊爲新的剪貼板格式。利用剪貼板進行交換的數據只需在數據格式上一致或均可以轉化爲某種格式就行。但剪貼板只能在基於Windows的程序中使用，不能在網絡上使用。
2.7 動態數據交換
　　動態數據交換(DDE)是使用共享內存在應用程序之間進行數據交換的一種進程間通訊形式。應用程序可使用DDE進行一次性數據傳輸，也能夠當出現新數據時，經過發送更新值在應用程序間動態交換數據。
　　DDE和剪貼板同樣既支持標準數據格式(如文本、位圖等)，又能夠支持本身定義的數據格式。但它們的數據傳輸機制卻不一樣，一個明顯區別是剪貼板操做幾乎老是用做對用戶指定操做的一次性應答－如從菜單中選擇Paste命令。儘管DDE也能夠由用戶啓動，但它繼續發揮做用通常沒必要用戶進一步干預。DDE有三種數據交換方式：
　　(1) 冷鏈：數據交換是一次性數據傳輸，與剪貼板相同。
　　(2) 溫鏈：當數據交換時服務器通知客戶，而後客戶必須請求新的數據。
　　(3) 熱鏈：當數據交換時服務器自動給客戶發送數據。
　　DDE交換能夠發生在單機或網絡中不一樣計算機的應用程序之間。開發者還能夠定義定製的DDE數據格式進行應用程序之間特別目的IPC，它們有更緊密耦合的通訊要求。大多數基於Windows的應用程序都支持DDE。
2.8 對象鏈接與嵌入
　　應用程序利用對象鏈接與嵌入(OLE)技術管理複合文檔(由多種數據格式組成的文檔)，OLE提供使某應用程序更容易調用其它應用程序進行數據編輯的服務。例如，OLE支持的字處理器能夠嵌套電子表格，當用戶要編輯電子表格時OLE庫可自動啓動電子表格編輯器。當用戶退出電子表格編輯器時，該表格已在原始字處理器文檔中獲得更新。在這裏電子表格編輯器變成了字處理器的擴展，而若是使用DDE，用戶要顯式地啓動電子表格編輯器。
　　同DDE技術相同，大多數基於Windows的應用程序都支持OLE技術。
2.9 動態鏈接庫
　　Win32動態鏈接庫(DLL)中的全局數據能夠被調用DLL的全部進程共享，這就又給進程間通訊開闢了一條新的途徑，固然訪問時要注意同步問題。
　　雖然能夠經過DLL進行進程間數據共享，但從數據安全的角度考慮，咱們並不提倡這種方法，使用帶有訪問權限控制的共享內存的方法更好一些。
2.10 遠程過程調用
　　Win32 API提供的遠程過程調用(RPC)使應用程序可使用遠程調用函數，這使在網絡上用RPC進行進程通訊就像函數調用那樣簡單。RPC既能夠在單機不一樣進程間使用也能夠在網絡中使用。
　　因爲Win32 API提供的RPC服從OSF-DCE(Open Software Foundation Distributed Computing Environment)標準。因此經過Win32 API編寫的RPC應用程序能與其它操做系統上支持DEC的RPC應用程序通訊。使用RPC開發者能夠創建高性能、緊密耦合的分佈式應用程序。
2.11 NetBios函數
　　Win32 API提供NetBios函數用於處理低級網絡控制，這主要是爲IBM NetBios系統編寫與Windows的接口。除非那些有特殊低級網絡功能要求的應用程序，其它應用程序最好不要使用NetBios函數來進行進程間通訊。
2.12 Sockets
　　Windows Sockets規範是以U.C.Berkeley大學BSD UNIX中流行的Socket接口爲範例定義的一套Windows下的網絡編程接口。除了Berkeley Socket原有的庫函數之外，還擴展了一組針對Windows的函數，使程序員能夠充分利用Windows的消息機制進行編程。
　　如今經過Sockets實現進程通訊的網絡應用愈來愈多，這主要的緣由是Sockets的跨平臺性要比其它IPC機制好得多，另外WinSock 2.0不只支持TCP/IP協議，並且還支持其它協議(如IPX)。Sockets的惟一缺點是它支持的是底層通訊操做，這使得在單機的進程間進行簡單數據傳遞不太方便，這時使用下面將介紹的WM_COPYDATA消息將更合適些。
2.13 WM_COPYDATA消息
　　WM_COPYDATA是一種很是強大卻不爲人知的消息。當一個應用向另外一個應用傳送數據時，發送方只需使用調用SendMessage函數，參數是目的窗口的句柄、傳遞數據的起始地址、WM_COPYDATA消息。接收方只需像處理其它消息那樣處理WM_COPY DATA消息，這樣收發雙方就實現了數據共享。
　　WM_COPYDATA是一種很是簡單的方法，它在底層其實是經過文件映射來實現的。它的缺點是靈活性不高，而且它只能用於Windows平臺的單機環境下。多線程

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程