Windows 多程式通訊API總結

查志強發表於2016-10-17
WindowsAPI

【原文：http://blog.csdn.net/u011000290/article/details/48108557】

在一個大型的應用系統中，往往需要多個程式相互協作，程式間通訊(IPC,Inter Process Communication)就顯得比較重要了。在Linux系統中，有很多種IPC機制，比如說，訊號(signal)、管道(pipe)、訊息佇列(message queue)、訊號量(semaphore)和共享記憶體(shared memory)、套接字(socket)等，其實Windows作業系統也支援這些東西。在IBM的Developerworks發現了一篇關於Windows與Linux 之間IPC機制API比較的文章，寫得很不錯，連結

http://www.ibm.com/developerworks/cn/linux/l-ipc2lin1.html

下面大部分內容是關於這些機制的API的實現。

建立程式

程式的建立可以呼叫CreateProcess函式，CreateProcess有三個重要的引數，執行程式的名稱、指向STARTUPINFO結構的指標、指向PROCESS_INFORMATION結構的指標。其原型如下：

[cpp] view plain copy
 print?
  1. BOOL CreateProcess  
  2. (  
  3. LPCTSTRlpApplicationName,  
  4. LPTSTR lpCommandLine,  
  5. LPSECURITY_ATTRIBUTES lpProcessAttributes。  
  6. LPSECURITY_ATTRIBUTES lpThreadAttributes,  
  7. BOOL bInheritHandles,  
  8. DWORD dwCreationFlags,  
  9. LPVOID lpEnvironment,  
  10. LPCTSTR lpCurrentDirectory,  
  11. LPSTARTUPINFOlpStartupInfo,  
  12. LPPROCESS_INFORMATIONlpProcessInformation  
  13. );  

給個例子，如果啟動時應用程式帶有命令列引數，程式將輸出命令列引數，並建立一個不帶任何引數的子執行緒；如果不帶有任何引數，則會輸出一條提示訊息。

[cpp] view plain copy
 print?
  1. #include <Windows.h>  
  2. #include <tchar.h>  
  3. #include <iostream>  
  4. using namespace std;  
  5. int _tmain(int argc, _TCHAR* argv[]){  
  6.     STARTUPINFO startup_info;  
  7.     PROCESS_INFORMATION process_info;  
  8.     if (argc>1)  
  9.     {  
  10.         cout<<"Argument"<<argv[1]<<endl;  
  11.         cout<<"開啟子執行緒"<<endl;  
  12.         ZeroMemory(&process_info,sizeof(process_info));  
  13.         ZeroMemory(&startup_info,sizeof(startup_info));  
  14.         startup_info.cb=sizeof(startup_info);  
  15.         if (CreateProcess(argv[0],0,0,0,0,0,0,0,&startup_info,&process_info)==0)  
  16.         {  
  17.             cout<<"Error"<<endl;  
  18.         }  
  19.         WaitForSingleObject(process_info.hProcess,INFINITE);  
  20.     }  
  21.     else{  
  22.         cout<<"No arguments"<<endl;  
  23.     }  
  24.     getchar();  
  25. }  

再給個例子，利用CreateProcess開啟一個新執行緒，啟動IE瀏覽器，開啟百度的主頁，5s後再將其關閉。


[cpp] view plain copy
 print?
  1. #include <Windows.h>  
  2. #include <tchar.h>  
  3. #include <iostream>  
  4. using namespace std;  
  5. #define IE L"C:\\Program Files\\Internet Explorer\\iexplore.exe"    
  6. #define CMD L"open http://www.baidu.com/"    
  7. int _tmain(int argc, _TCHAR* argv[]){  
  8.     STARTUPINFO startup_info;  
  9.     GetStartupInfo(&startup_info);  
  10.     PROCESS_INFORMATION process_info;  
  11.     startup_info.dwFlags=STARTF_USESHOWWINDOW;  
  12.     startup_info.wShowWindow=SW_HIDE;  
  13.     if (!CreateProcess(IE,CMD,NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL,&startup_info,&process_info))  
  14.     {  
  15.         cout<<"Create Process Error："<<GetLastError()<<endl;  
  16.         return 0;  
  17.     }  
  18.     Sleep(5000);  
  19.     TerminateProcess(process_info.hProcess,0);  
  20.     return 0;  
  21. }  

被建立的控制程式碼通過process_info.hProcess返回。如果傳遞引數給新的程式，第一個命令列引數必須重複應用程式名稱，整個命令列會被傳遞給子程式。


傳遞引數給新程式。

[cpp] view plain copy
 print?
  1. #include <Windows.h>  
  2. #include <tchar.h>  
  3. #include <iostream>  
  4. using namespace std;  
  5. int _tmain(int argc, _TCHAR* argv[]){  
  6.     STARTUPINFO startup_info;  
  7.     PROCESS_INFORMATION process_info;  
  8.     if (argc==1)  
  9.     {  
  10.         cout<<"No arguments given starting child process"<<endl;  
  11.         wchar_t argument[256];  
  12.         wsprintf(argument,L"\"%s\" Hello",argv[0]);  
  13.         ZeroMemory(&process_info,sizeof(process_info));  
  14.         ZeroMemory(&startup_info,sizeof(startup_info));  
  15.         startup_info.cb=sizeof(startup_info);  
  16.         if (CreateProcess(argv[0],argument,0,0,0,0,0,0,&startup_info,&process_info)==0)  
  17.         {  
  18.             cout<<"Error "<<GetLastError()<<endl;  
  19.         }  
  20.         WaitForSingleObject(process_info.hProcess,INFINITE);  
  21.     }  
  22.     else{  
  23.         cout<<"Argument "<<argv[1]<<endl;  
  24.     }  
  25.     getchar();  
  26. }  



IPC

程式間可以共享記憶體，程式建立具有共享屬性的記憶體區域後，另一個程式可以開啟此記憶體區域，並將其對映到自己的地址空間。共享記憶體可以使用檔案對映函式CreateFileMapping，建立共享記憶體區域的控制程式碼，通過MapViewOfFile()把這個區域對映到程式，然後再連線到現有的共享記憶體區域，可以通過OpenFileMapping獲得控制程式碼。在程式使用完共享記憶體後，需要呼叫UnmapViewOfFile()取消對映，再呼叫CloseHandle()關閉相應的控制程式碼，避免記憶體洩露。

給個例子，如果啟動時應用程式不帶任何引數，應用程式會建立一個子程式。父程式也將建立一個共享記憶體區域，並將一個字串儲存到共享記憶體。共享記憶體取名為sharedmemory，在Local\名稱空間中建立，即該共享記憶體對該使用者所有的全部程式可見。(程式的名稱空間分為兩種，全域性名稱空間以Global\識別符號開頭，本地名稱空間以Local\開頭)

[cpp] view plain copy
 print?
  1. #include <Windows.h>  
  2. #include <tchar.h>  
  3. #include <iostream>  
  4. using namespace std;  
  5. int _tmain(int argc, _TCHAR* argv[]){  
  6.     STARTUPINFO startup_info;  
  7.     PROCESS_INFORMATION process_info;  
  8.     HANDLE filehandle;  
  9.     TCHAR ID[]=TEXT("Local\\sharedmemory");  
  10.     char* memory;  
  11.     if (argc==1)  
  12.     {  
  13.         filehandle=CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,0,1024,ID);  
  14.         memory=(char*)MapViewOfFile(filehandle,FILE_MAP_ALL_ACCESS,0,0,0);  
  15.         sprintf_s(memory,1024,"%s","Data from first process");  
  16.         cout<<"First process:"<<memory<<endl;  
  17.         ZeroMemory(&process_info,sizeof(process_info));  
  18.         ZeroMemory(&startup_info,sizeof(startup_info));  
  19.         startup_info.cb=sizeof(startup_info);  
  20.   
  21.         wchar_t cmdline[256];  
  22.         wsprintf(cmdline,L"\"%s\" Child\n",argv[0]);  
  23.         CreateProcessW(argv[0],cmdline,0,0,0,0,0,0,&startup_info,&process_info);  
  24.         WaitForSingleObject(process_info.hProcess,INFINITE);  
  25.           
  26.         UnmapViewOfFile(memory);  
  27.         CloseHandle(filehandle);  
  28.     }  
  29.     else{  
  30.         filehandle=OpenFileMapping(FILE_MAP_ALL_ACCESS,0,ID);  
  31.         memory=(char*)MapViewOfFile(filehandle,FILE_MAP_ALL_ACCESS,0,0,0);  
  32.         cout<<"Second process: "<<memory;  
  33.         UnmapViewOfFile(memory);  
  34.         CloseHandle(filehandle);  
  35.     }  
  36.     getchar();  
  37.     return 0;  
  38. }  



從結果可以看出，子程式連線到共享記憶體，並能輸出父程式儲存在那裡的字串。子程式輸出字串以後，就取消記憶體對映，關閉檔案控制程式碼，然後退出。子程式退出後，父程式就可以取消記憶體對映、關閉檔案控制程式碼並退出。


子程式可以繼承父程式所有資源的控制程式碼，最簡單的方法是通過命令列傳遞值。


[cpp] view plain copy
 print?
  1. #include <Windows.h>  
  2. #include <tchar.h>  
  3. #include <iostream>  
  4. using namespace std;  
  5. int _tmain(int argc, _TCHAR* argv[]){  
  6.     STARTUPINFO startup_info;  
  7.     PROCESS_INFORMATION process_info;  
  8.     SECURITY_ATTRIBUTES sa;  
  9.     HANDLE filehandle;  
  10.     TCHAR ID[]=TEXT("Local\\sharedmemory");  
  11.     wchar_t* memory;  
  12.     if (argc==1)  
  13.     {  
  14.         //父程式  
  15.         sa.nLength=sizeof(sa);//設定安全屬性  
  16.         sa.bInheritHandle=TRUE;//使控制程式碼可以被繼承  
  17.         sa.lpSecurityDescriptor=NULL;  
  18.   
  19.         filehandle=CreateFileMapping(INVALID_HANDLE_VALUE,&sa,PAGE_READWRITE,0,1024,ID);  
  20.         memory=(wchar_t*)MapViewOfFile(filehandle,FILE_MAP_ALL_ACCESS,0,0,0);  
  21.         //用共享記憶體設定命令列  
  22.         swprintf(memory,1024,L"\"%s\" %i",argv[0],filehandle);  
  23.         cout<<"First process memory:"<<memory<<"  handle: "<<filehandle<<endl;  
  24.         ZeroMemory(&process_info,sizeof(process_info));  
  25.         ZeroMemory(&startup_info,sizeof(startup_info));  
  26.         startup_info.cb=sizeof(startup_info);  
  27.   
  28.         //啟動子程式  
  29.         CreateProcess(NULL,memory,0,0,true,0,0,0,&startup_info,&process_info);  
  30.         WaitForSingleObject(process_info.hProcess,INFINITE);  
  31.         UnmapViewOfFile(memory);  
  32.         CloseHandle(filehandle);  
  33.     }  
  34.     else{  
  35.         filehandle=(HANDLE)_wtoi(argv[1]);//從argv[1]獲得控制程式碼  
  36.         memory=(wchar_t*)MapViewOfFile(filehandle,FILE_MAP_ALL_ACCESS,0,0,0);  
  37.         cout<<"Second process memory : "<<memory<<"  handle: "<<filehandle<<endl;  
  38.         UnmapViewOfFile(memory);  
  39.         CloseHandle(filehandle);  
  40.     }  
  41.     getchar();  
  42.     return 0;  
  43. }  



程式間共享互斥量，可以通過呼叫CreateMutex或者OpenMutex函式來獲取互斥量的控制程式碼。但是，只有一個程式可以建立互斥量，其他的程式只能開啟現有的互斥量；互斥量的名稱必須唯一；互斥量的名稱必須傳遞給其他程式。

[cpp] view plain copy
 print?
  1. #include <Windows.h>  
  2. #include <tchar.h>  
  3. #include <iostream>  
  4. using namespace std;  
  5. int _tmain(int argc, _TCHAR* argv[]){  
  6.     HANDLE sharedmutex;  
  7.     STARTUPINFO startup_info;  
  8.     PROCESS_INFORMATION process_info;  
  9.     ZeroMemory(&process_info,sizeof(process_info));  
  10.     ZeroMemory(&startup_info,sizeof(startup_info));  
  11.     startup_info.cb=sizeof(startup_info);  
  12.   
  13.     sharedmutex=CreateMutex(0,0,L"mymutex");  
  14.     if (GetLastError()!=ERROR_ALIAS_EXISTS)  
  15.     {  
  16.         if (CreateProcess(argv[0],0,0,0,0,0,0,0,&startup_info,&process_info)==0)  
  17.         {  
  18.             cout<<"Error : "<<GetLastError()<<endl;  
  19.         }  
  20.         WaitForSingleObject(process_info.hProcess,INFINITE);  
  21.     }  
  22.   
  23.     WaitForSingleObject(sharedmutex,INFINITE);  
  24.     for (int i=0;i<100;i++)  
  25.     {  
  26.         cout<<"Process "<<GetCurrentProcessId()<<" count"<<i<<endl;  
  27.     }  
  28.     ReleaseMutex(sharedmutex);  
  29.     CloseHandle(sharedmutex);  
  30.     getchar();  
  31.     return 0;  
  32. }  



使用共享互斥量來確保兩個程式中一次只有一個能計數從0數到19，如果沒有互斥量的話，那麼兩個程式可能同時在跑，則控制檯的輸出將是混合的輸出，使用互斥量以後，一次只有一個程式在輸出。

 

也可以用管道進行通訊，管道是流式通訊的一種方式，管道有兩種命名管道和匿名管道。匿名管道的建立可以呼叫CreatePipe()，建立命名管道可以呼叫CreateNamedPipe()，呼叫WriteFile通過管道傳送資料，ReadFile從管道讀取資料。

[cpp] view plain copy
 print?
  1. #include <Windows.h>  
  2. #include <tchar.h>  
  3. #include <process.h>  
  4. #include <iostream>  
  5. #include <stdio.h>  
  6. using namespace std;  
  7. HANDLE readpipe,writepipe;  
  8. unsigned int __stdcall stage1(void * param)  
  9. {  
  10.     char buf[200];  
  11.     DWORD len;  
  12.     for (int i=0;i<10;i++)  
  13.     {  
  14.         sprintf(buf,"Text %i",i);  
  15.         WriteFile(writepipe,buf,strlen(buf)+1,&len,0);  
  16.     }  
  17.     CloseHandle(writepipe);  
  18.     return 0;  
  19. }  
  20. unsigned int __stdcall stage2(void * param)  
  21. {  
  22.     char buf[200];  
  23.     DWORD len;  
  24.     while(ReadFile(readpipe,buf,200,&len,0))  
  25.     {  
  26.         DWORD offset=0;  
  27.         while(offset<len)  
  28.         {  
  29.             cout<<&buf[offset]<<endl;  
  30.             offset+=strlen(&buf[offset])+1;  
  31.         }  
  32.     }  
  33.     CloseHandle(readpipe);  
  34.     return 0;  
  35. }  
  36. int _tmain(int argc, _TCHAR* argv[]){  
  37.     HANDLE thread1,thread2;  
  38.     CreatePipe(&readpipe,&writepipe,0,0);  
  39.     thread1=(HANDLE)_beginthreadex(0,0,&stage1,0,0,0);  
  40.     thread2=(HANDLE)_beginthreadex(0,0,&stage2,0,0,0);  
  41.     WaitForSingleObject(thread1,INFINITE);  
  42.     WaitForSingleObject(thread2,INFINITE);  
  43.     getchar();  
  44.     return 0;  
  45. }  

第一個執行緒將文字資訊放入管道，第二個執行緒接收並輸出這些資訊。

還可以用套接字進行通訊。WindowsSockets API以BSD Sockets API為基礎，與類UNIX作業系統的程式碼很相似。

[cpp] view plain copy
 print?
  1. #ifndef WIN32_LEAN_AND_MEAN  
  2. #define WIN32_LEAN_AND_MEAN  
  3. #endif  
  4. #include <Windows.h>  
  5. #include <tchar.h>  
  6. #include <process.h>  
  7. #include <WinSock2.h>  
  8. #include <iostream>  
  9. #include <stdio.h>  
  10. #pragma comment(lib,"ws2_32.lib")  
  11. using namespace std;  
  12. HANDLE hevent;  
  13. //響應執行緒  
  14. void handleecho(void *data)  
  15. {  
  16.     char buf[1024];  
  17.     int count;  
  18.     ZeroMemory(buf,sizeof(buf));  
  19.     int socket=(int)data;  
  20.     while((count=recv(socket,buf,1023,0))>0)  
  21.     {  
  22.         cout<<"received "<<buf<<"from client"<<endl;  
  23.         int ret=send(socket,buf,count,0);  
  24.     }  
  25.     cout<<"close echo thread"<<endl;  
  26.     shutdown(socket,SD_BOTH);  
  27.     closesocket(socket);  
  28. }  
  29. //客戶端執行緒  
  30. unsigned int __stdcall client(void *data)  
  31. {  
  32.     SOCKET ConnectSockket=socket(AF_INET,SOCK_STREAM,0);  
  33.   
  34.     WaitForSingleObject(hevent,INFINITE);  
  35.   
  36.     struct sockaddr_in server;  
  37.     ZeroMemory(&server,sizeof(server));  
  38.     server.sin_family=AF_INET;  
  39.     server.sin_addr.s_addr=inet_addr("192.168.1.107");  
  40.     server.sin_port=7780;  
  41.   
  42.     connect(ConnectSockket,(struct sockaddr*)&server,sizeof(server));  
  43.   
  44.     cout<<"send 'abcd' to server"<<endl;  
  45.     char buf[1024];  
  46.     ZeroMemory(buf,sizeof(buf));  
  47.     strncpy_s(buf,1024,"abcd",5);  
  48.     send(ConnectSockket,buf,strlen(buf)+1,0);  
  49.   
  50.     ZeroMemory(buf,sizeof(buf));  
  51.     recv(ConnectSockket,buf,1024,0);  
  52.     //cout<<"get "<<buf<<"from server"<<endl;  
  53.     printf("get '%s' from server\n",buf);  
  54.   
  55.     cout<<"close client"<<endl;  
  56.     shutdown(ConnectSockket,SD_BOTH);  
  57.     closesocket(ConnectSockket);  
  58.     return 0;  
  59. }  
  60. //伺服器執行緒  
  61. unsigned int __stdcall server(void *data)  
  62. {  
  63.     SOCKET newsocket;  
  64.     SOCKET ServerSocket=socket(AF_INET,SOCK_STREAM,0);  
  65.   
  66.     struct sockaddr_in server;  
  67.     ZeroMemory(&server,sizeof(server));  
  68.     server.sin_family=AF_INET;  
  69.     server.sin_addr.s_addr=INADDR_ANY;  
  70.     server.sin_port=7780;  
  71.   
  72.     bind(ServerSocket,(struct sockaddr*)&server,sizeof(server));  
  73.     listen(ServerSocket,SOMAXCONN);  
  74.   
  75.     SetEvent(hevent);  
  76.   
  77.     while((newsocket=accept(ServerSocket,0,0))!=INVALID_SOCKET)  
  78.     {  
  79.         HANDLE newthread;  
  80.         newthread=(HANDLE)_beginthread(&handleecho,0,(void *)newsocket);  
  81.     }  
  82.   
  83.     cout<<"close server"<<endl;  
  84.     shutdown(ServerSocket,SD_BOTH);  
  85.     closesocket(ServerSocket);  
  86.     return 0;  
  87. }  
  88. //主執行緒啟動客戶端執行緒和服務端執行緒  
  89. int _tmain(int argc, _TCHAR* argv[]){  
  90.     HANDLE serverthread,clienthread;  
  91.     WSADATA wsaData;  
  92.   
  93.     WSAStartup(MAKEWORD(2,2),&wsaData);  
  94.     hevent=CreateEvent(0,true,0,0);  
  95.   
  96.     serverthread=(HANDLE)_beginthreadex(0,0,&server,0,0,0);  
  97.     clienthread=(HANDLE)_beginthreadex(0,0,&client,0,0,0);  
  98.     WaitForSingleObject(clienthread,INFINITE);  
  99.     CloseHandle(clienthread);  
  100.   
  101.     CloseHandle(hevent);  
  102.     getchar();  
  103.     WSACleanup();  
  104.     return 0;  
  105. }  

伺服器執行緒的第一個操作是開啟一個套接字，接著繫結連線。套接字置於監聽狀態，值SOMAXCONN包含排隊等待接受的連線的最大值。然後伺服器發訊號給事件，事件繼而使客戶端執行緒嘗試連線。接著，主執行緒迴圈等待接受連線，直到收到INVALID_SOCKET的連線。Windows套接字關閉時會發生這種情況。伺服器執行緒在其他執行緒退出後清理退出。伺服器每次接受一個連線時都會建立一個新執行緒，且新連線的標識會傳遞給新建立的執行緒。當迴圈收到INVALID_SOCKET時，伺服器執行緒關閉，然後關閉套接字。

 


Windows API也提供了很多原子操作，互鎖函式。InterlockedIncrement就是一個互鎖函式。

[cpp] view plain copy
 print?
  1. #include <Windows.h>  
  2. #include <tchar.h>  
  3. #include <process.h>  
  4. #include <iostream>  
  5. using namespace std;  
  6. int isPrime(int num)    
  7. {    
  8.     int i;    
  9.     for (i=2;i<(int)(sqrt((float)num)+1.0);i++)    
  10.     {    
  11.         if (num%i==0)    
  12.             return 0;    
  13.     }    
  14.     return 1;    
  15. }    
  16. volatile long counter=2;    
  17. unsigned int __stdcall test(void *)    
  18. {    
  19.     while (counter<20)    
  20.     {    
  21.         int num=InterlockedIncrement(&counter);  
  22.         //int num=counter++;    
  23.         printf("Thread ID : %i; value = %i, is prime = %i\n",GetCurrentThreadId(),num,isPrime(num));    
  24.     }    
  25.     return 0;    
  26. }    
  27. int _tmain(int argc,_TCHAR* argv[])    
  28. {    
  29.     HANDLE h1,h2;    
  30.     h1=(HANDLE)_beginthreadex(0,0,&test,(void *)0,0,0);    
  31.     h2=(HANDLE)_beginthreadex(0,0,&test,(void *)0,0,0);    
  32.     WaitForSingleObject(h1,INFINITE);    
  33.     WaitForSingleObject(h2,INFINITE);    
  34.     CloseHandle(h1);    
  35.     CloseHandle(h2);    
  36.     getchar();    
  37.     return 0;    
  38. }   

還有一個問題就是執行緒本地儲存(TLS, ThreadLocal Storage)，TLS 是一個機制，利用該機制，程式可以擁有全域性變數，但處於“每一執行緒各不相同”的狀態。也就是說，程式中的所有執行緒都可以擁有全域性變數，但這些變數其實是特定對某個執行緒才有意義，各個執行緒擁有全域性變數的一個副本，各自之間不相影響。每個執行緒訪問資料的方式相同，但看不到其他執行緒持有的值。比如說，定義一個全域性變數int a=10，那麼線上程1中對a進行操作a=a-1，如果沒用TLS，那麼執行緒2開始獲得的a就是9。但是，如果採取了TLS，不管執行緒1中對a的值進行了如何的修改操作，其他的執行緒一開始獲得的a還是10，不會被修改。這個全域性的變數a是沒有儲存線上程堆疊中的，是在全域性的堆疊中，但是卻被各個執行緒“共享”且互不影響。可以認為執行緒本地儲存的本質是“全域性”資料的作用域受到了執行執行緒的限制。

執行緒本地分配可以呼叫__declspec、TlsAlloc()等函式。TlsAlloc可以分配全域性索引，該索引由所有執行緒共享，但是每個執行緒儲存在索引中的資料為呼叫的執行緒私有，也就是說其他執行緒看不到持有的值。當不再需要全域性索引提供執行緒本地儲存時，可以呼叫TlsFree來釋放全域性索引。

給個例子。

[cpp] view plain copy
 print?
  1. #include <Windows.h>  
  2. #include <tchar.h>  
  3. #include <process.h>  
  4. #include <iostream>  
  5. using namespace std;  
  6. DWORD TLSIndex;  
  7. void setdata(int value)  
  8. {  
  9.     cout<<"Thread "<<GetCurrentThreadId()<<": set value = "<<value<<endl;  
  10.     TlsSetValue(TLSIndex,(void*)value);  
  11. }  
  12. void getdata()  
  13. {  
  14.     int value;  
  15.     value=(int)TlsGetValue(TLSIndex);  
  16.     cout<<"Thread "<<GetCurrentThreadId()<<": has value = "<<value<<endl;  
  17. }  
  18. unsigned int __stdcall workthread(void *data)  
  19. {  
  20.     int value=(int)data;  
  21.     cout<<"Thread "<<GetCurrentThreadId()<<": got value = "<<value<<endl;  
  22.     setdata(value);  
  23.     Sleep(1000);  
  24.     getdata();  
  25.     return 0;  
  26. }  
  27. int _tmain(int argc,_TCHAR* argv[])    
  28. {  
  29.     HANDLE h[8];  
  30.     TLSIndex=TlsAlloc();  
  31.     for (int i=0;i<8;i++)  
  32.     {  
  33.         h[i]=(HANDLE)_beginthreadex(0,0,&workthread,(void*)i,0,0);  
  34.     }  
  35.     for (int i=0;i<8;i++)  
  36.     {  
  37.         WaitForSingleObject(h[i],INFINITE);  
  38.     }  
  39.     TlsFree(TLSIndex);  
  40.     getchar();  
  41.     return 0;  
  42. }  

執行緒本地儲存用於儲存傳給各個執行緒的值，每個執行緒在被建立的時候就被傳遞一個唯一的值，並通過setdata儲存線上程本地儲存中。getdata可以讀取執行緒本地值，每個執行緒呼叫setdata方法，接著休眠1s讓其他執行緒執行，然後呼叫getdata讀取資料。

 

還有個問題，就是優先順序的問題。執行緒的優先順序越高，獲得的CPU資源(時間)就越多。在有些情況下，調整一個應用程式中不同執行緒的優先順序會非常有用。比如說，當某個應用執行一個長時間的後臺任務時，為了保證機器的高響應性，這個後臺任務最好以低優先順序執行。

Windows作業系統中提供了相關的API。

[cpp] view plain copy
 print?
  1. #include <Windows.h>  
  2. #include <tchar.h>  
  3. #include <process.h>  
  4. #include <iostream>  
  5. #include <time.h>  
  6. using namespace std;  
  7. unsigned int __stdcall fastthread(void *data)  
  8. {  
  9.     double d=1.0;  
  10.     cout<<"fast thread started"<<endl;  
  11.     SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_ABOVE_NORMAL);  
  12.     clock_t start=clock();  
  13.     for (int i=0;i<1000000000;i++)  
  14.     {  
  15.         d+=i;  
  16.     }  
  17.     clock_t end=clock();  
  18.     cout<<"fast thread finished, it takes "<<(double)(end-start)/CLOCKS_PER_SEC<<"s to finish the task"<<endl;  
  19.     return 0;  
  20. }  
  21. unsigned int __stdcall slowthread(void *data)  
  22. {  
  23.     double d=0.0;  
  24.     cout<<"slow thread started"<<endl;  
  25.     SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_BELOW_NORMAL);  
  26.     clock_t start=clock();  
  27.     for (int i=0;i<1000000000;i++)  
  28.     {  
  29.         d+=i;  
  30.     }  
  31.     clock_t end=clock();  
  32.     cout<<"slow thread finished, it takes "<<(double)(end-start)/CLOCKS_PER_SEC<<"s to finnish the task"<<endl;  
  33.     return 0;  
  34. }  
  35. int _tmain(int argc,_TCHAR* argv[])    
  36. {  
  37.     HANDLE fast,slow;  
  38.     slow=(HANDLE)_beginthreadex(0,0,&slowthread,0,0,0);  
  39.     fast=(HANDLE)_beginthreadex(0,0,&fastthread,0,0,0);  
  40.     WaitForSingleObject(fast,INFINITE);  
  41.     WaitForSingleObject(slow,INFINITE);  
  42.     getchar();  
  43.     return 0;  
  44. }  


有時候調整執行緒的優先順序會帶來優先順序反轉的問題。

小結

主要實現了windows作業系統中IPC的API，主要有程式之間共享記憶體、子程式中繼承控制程式碼、互斥量、管道、套接字等。此外，還有Windows中的互鎖函式。執行緒本地化儲存(TLS)、執行緒的優先順序等。



相關文章