锁定模式下的非锁定实现

锁定模式下的非锁定实现

Lanno Ckeeke 　2006060701

说明

锁定模式下为了避免socket在进行IO操作时一直处于“凝固”状态，简单地用两个线程来实现：一个线程用于数据的接收；另一个线程则用于对接收到的数据进行相关的处理。因为由两个线程来实现，其特点：

①     对数据的处理可以是耗时操作，它不会对数据的接收带来影响。

②     对数据的接收与处理分别在不同的线程内，故应考虑数据的完整性，应避免在数据接收完全之前就对数据进行操作，可以以多种方式实现：如Mutex,Semphore,CriticalSection等同步技术。

③     当数据接收完全之后，还需要及时的通知另一个线程，以便及时处理。其实现方法是：当接收完数据后，发送已完成信号。

详细说明参见＜Windows网络编程＞一书。

本代码中应用CriticalSection和event来实现。

需要注意的是：event为自动重置。

完整代码及注释

1. // zBlogSocket.cpp : 定义控制台应用程序的入口点。
3. //
5. //多线程socket锁定
7.  
9. #include "stdafx.h"
11. #include <WinSock2.h>
13. #include <Windows.h>
15. #include <iostream>
17. using namespace std;
19.  
21. CRITICAL_SECTION cs;
23. HANDLE hComplete;
25. TCHAR buf[BUFSIZ];
27. int nBytes;
29. //number of per receive
31. const int nNumPerRecv = BUFSIZ;
33.  
35. //从socket接收数据线程
37. DWORD WINAPI ReadThread(LPVOID lpParam);
39. //对接受到的数据进行计算的线程
41. DWORD WINAPI ComptThread(LPVOID lpParam);
43.  
45. int _tmain(int argc, _TCHAR* argv[])
47. {
49.      WSAData wsd;
51.      int nRet = WSAStartup(0x0202,&wsd);
53.      if (nRet != 0) {
55.           cout << "WSAStartup Error = " << WSAGetLastError() << endl;
57.          return 1;
59.      }
61.  
63.      SOCKET soRecv = socket(AF_INET,SOCK_STREAM,0);
65.      SOCKADDR_IN siRecv;
67.      siRecv.sin_addr.s_addr = inet_addr("127.0.0.1");
69.      siRecv.sin_family = AF_INET;
71.      siRecv.sin_port = htons(5150);
73.  
75.      nRet = bind(soRecv,(struct sockaddr*)&siRecv,sizeof(siRecv));
77.      if (nRet == SOCKET_ERROR) {
79.          cout << "bind Error = " << WSAGetLastError() << endl;
81.          return 1;
83.      }
85.  
87.      listen(soRecv,8);
89.  
91.  
93.      HANDLE hThreads[2];
95.      DWORD dwThread[2];
97.  
99.      //初始化cs
101.      InitializeCriticalSection(&cs);
103.  
105.      hThreads[0] = CreateThread(NULL,0,ReadThread,(LPVOID)soRecv,0,&dwThread[0]);
107.      hThreads[1] = CreateThread(NULL,0,ComptThread,NULL,0,&dwThread[1]);
109.     
111.      //创建自动重置的event对象，当ReadThread接收数据完毕
113.      //后将信号置为signaled
115.      hComplete = CreateEvent(NULL,false,FALSE,"evt");
117.     
119.      //等待创建的两个线程结束
121.      WaitForMultipleObjects(2,hThreads,true,INFINITE);
123.  
125.      //清除cs
127.      DeleteCriticalSection(&cs);
129.  
131.      return 0;
133. }
135.  
137. //从socket接收数据线程
139. DWORD WINAPI ReadThread(LPVOID lpParam){
141.      int nTotal = 0;
143.      int nRead = 0;
145.      int nLeft = 0;
147.      int nReadBytes = 0;
149.      int nBytes = 0;
151.      SOCKET pSoRecv = (SOCKET)lpParam;
153.      int dwSend;
155.      SOCKADDR_IN siSend;
157.      SOCKET soAccept;
159.  
161.  
163.      while (1) {
165.  
167.          nTotal = 0;
169.          nLeft = nNumPerRecv;
171.  
173.          /*   10014错误原因
175.          *    int dwSend = sizeof(dwSend);
177.               Error = 10014
179.          */
181.          int dwSend = sizeof(siSend);
183.          soAccept = accept(pSoRecv,(struct sockaddr*)&siSend,&dwSend);
185.          if (soAccept == SOCKET_ERROR) {
187.               cout << "accept Error = " << WSAGetLastError() << endl;
189.               system("pause");
191.  
193.          }
195.  
197.  
199.          //接收到的数据为空
201.          nBytes = 0;
203.          memset(buf,0,BUFSIZ);
205.          while (nTotal != nNumPerRecv) {
207.               //同步操作进入cs
209.               EnterCriticalSection(&cs);
211.               /*
213.                *   Recv data from socket and place data in buf[nBytes]
215.                */
217.               //nRead = recv(soAccept,&buf[BUFSIZ - nBytes],nLeft,0);
219.               nRead = recv(soAccept,&buf[nBytes],nLeft,0);
221.               if (nRead == -1) {
223.                    cout << "recv error = " << WSAGetLastError() << endl;
225.                    ExitThread(1);
227.               }
229.               nTotal += nRead;
231.               nLeft -= nRead;
233.               nBytes += nRead;
235.               //离开cs
237.               LeaveCriticalSection(&cs);
239.  
241.          }
243.          //激发event
245.          SetEvent(hComplete);
247.      }
249. }
251. //对接受到的数据进行计算的线程
253. DWORD WINAPI ComptThread(LPVOID lpParam){
255.      //等待ReadThread将数据接受完成后再进行计算
257.      while (1) {
259.          WaitForSingleObject(hComplete,INFINITE);
261.  
263.          //对全局变量操作进入cs
265.          EnterCriticalSection(&cs);
267.          cout << buf << endl;
269.          nBytes -= nNumPerRecv;
271.          //离开cs
273.          LeaveCriticalSection(&cs);
275.      }
277.  
279.      return 0;
281.  
283. }