第十九章 Windows平台下线程的使用

1. bcd

2. bd

3. 请比较从内存中完全销毁Windows线程和Linux线程的方法

   Windows上的线程销毁是随其线程main函数的返回，在内存中自动销毁的。但是linux的线程销毁必须经过pthread_join函数或者pthread_detach函数的响应才能在内存空间中完全销毁

4. 通过线程创建过程解释内核对象、线程、句柄之间的关系

   线程也属于操作系统的资源，因此会伴随着内核对象的创建，并为了引用内核对象而返回句柄。整理的话，可以通过句柄区分内核对象，通过内核对象区分线程

5. √ × ×

6. 请解释"auto-reset模式"和"manual-reset模式"的内核对象。区分二者的内核对象特征是什么？

   WaitForSingleObject函数针对单个内核对象验证signaled状态时，由于发生事件(变为signaled状态)返回时，有时会把相应内核对象再次改为non-signaled状态。这种可以再次进入non-signaled状态的内核对象称为"auto-reset模式"的内核对象，而不会自动跳转到non-signaled状态的内核对象称为"manual-reset模式"的内核对象。

第二十章 Windows中的线程同步

1. c

2. × √ × √

3. 本章示例SyncSema_win.c的Read函数中，退出临界区需要较长时间，请给出解决方案并实现

   对可能超过一定时间处于阻塞状态的函数，如scanf函数的响应，应尽量不纳入临界区

   unsigned WINAPI Read(void * arg)
   {
      int i, rdData;
      for(i=0; i<5; i++)
      {
          fputs("Input num: ", stdout);
          scanf("%d", &rdData);
          
          WaitForSingleObject(semTwo, INFINITE);
          num=rdData;
          ReleaseSemaphore(semOne, 1, NULL);
      }
      return 0;	
   }
   
   

4. 更改程序，并运行结果

   #include <stdio.h>
   #include <windows.h>
   #include <process.h> 
   #define STR_LEN		100
   
   unsigned WINAPI NumberOfA(void *arg);
   unsigned WINAPI NumberOfOthers(void *arg);
   
   static char str[STR_LEN];
   static HANDLE hSema;
   
   int main(int argc, char *argv[]) 
   {	
   	HANDLE  hThread1, hThread2;
   
   	hSema=CreateSemaphore(NULL, 0, 2, NULL);
   	hThread1=(HANDLE)_beginthreadex(NULL, 0, NumberOfA, NULL, 0, NULL);
   	hThread2=(HANDLE)_beginthreadex(NULL, 0, NumberOfOthers, NULL, 0, NULL);
   
   	fputs("Input string: ", stdout); 
   	fgets(str, STR_LEN, stdin);
   	ReleaseSemaphore(hSema, 2, NULL);
   
   	WaitForSingleObject(hThread1, INFINITE);
   	WaitForSingleObject(hThread2, INFINITE);
   	ResetEvent(hSema);
    	CloseHandle(hSema);
       return 0;
   }
   
   unsigned WINAPI NumberOfA(void *arg) 
   {
   	int i, cnt=0;
   	WaitForSingleObject(hSema, INFINITE);
   	for(i=0; str[i]!=0; i++)
   	{
   		if(str[i]=='A')
   			cnt++;
   	}
   	printf("Num of A: %d \n", cnt);
   	return 0;
   }
   unsigned WINAPI NumberOfOthers(void *arg) 
   {
   	int i, cnt=0;
   	WaitForSingleObject(hSema, INFINITE);
   	for(i=0; str[i]!=0; i++) 
   	{
   		if(str[i]!='A')
   			cnt++;
   	}
   	printf("Num of others: %d \n", cnt-1);
   	return 0;
   }
   

第二十一章 异步通知I/O模型

1. 结合send & recv 函数解释同步和异步方式的I/O。并请说明同步I/O的缺点，以及怎样通过异步I/O进行解决

   同步I/O是指数据发送的时间点和函数返回的时间一致的I/O方式。即，send函数返还的时间是数据传输完毕的时间，recv函数返还的时间是数据接收完毕的时间。但是异步I/O是指I/O函数的返回时刻与数据收发的完成时刻不一致。同步I/O的缺点是，直到输入输出完成为止，都处于阻塞状态。在这段时间里，CPU实际上是没有被利用的，但由于阻塞状态，无法进行其他工作。从这一点看，异步I/O对CPU的使用效率优于同步I/O

2. 异步I/O并不是所有状况下的最佳选择。它具有哪些缺点？何种情况下同步I/O更优？可以参考异步I/O相关源代码，亦可结合线程进行说明

   异步I/O有优点也有缺点，缺点在于要在完成输入输出以后去确认。如果服务器的服务非常简单，回复所需的数据量很小，就会很不方便。特别是在每一个用户都生成一个线程的服务器中，没有必要一定使用异步I/O

3. 全√

4. 请从源代码的角度说明select函数和WSAEventSelect函数再使用上的差异

   使用select函数时，要循环将观察的文件描述符传到select函数中。而如果使用WSAEventSelect函数，观察的对象会被操作系统记录下俩，无需每次都注册。而且，如果是用select函数，则到事件发生为止，应保持阻塞状态；而如果使用WSAEventSelect函数，到事件发生为止，都不应该进入阻塞。

5. 第17章的epoll可以在条件触发和边缘触发这2中方式下工作。那种方式更适合异步I/O模型？为什么？请概括说明

   边缘触发很好地配合异步I/O模型。边缘触发模式并不会因为输入缓冲中有数据而发起消息。即在边缘触发中，对异步的存取发生过程，不会发起消息，而只注册新的输入事件。但是在条件触发中，当输入缓冲中有有数据时，仍然会发起消息

6. Linux中的epoll同样属于异步I/O模型。请说明原因

   epoll方式将观察的对象的连接过程和事件发生过程分离成两种处理模式。因此，可以在事件发生后，在希望的时间确认活动是否发生。因此epoll可以说是一种异步I/O模式

7. 如何获取WSAWaitForMultipleEvents可以监视的最大句柄数？请编写代码读取该值

   获取WSA_MAXIMUM_WAIT_EVENTS的值即可

8. 为何异步通知I/O模型中的事件对象必须是manual-reset模式

   事件的发生，需要由WSAWaitForMultipleEvents函数调用寻找相应的句柄调用执行的；首先通过调用WSAWaitForMultipleEvents函数寻找事件发生的句柄数目，然后遍历找到具体发生的事件进行处理。如果不是manual-reset模式，就会自动转换为signaled状态，无法用第二次的WSAWaitForMultipleEvents函数进行操作处理

9. 代码

   /*****************************AysnNotiChatServ.c*****************************/
   #include <stdio.h>
   #include <string.h>
   #include <winsock2.h>
   
   #define BUF_SIZE 100
   
   void SendMsg(SOCKET clntSocks[], int clntCnt, char * msg, int len);
   void CompressSockets(SOCKET hSockArr[], int idx, int total);
   void CompressEvents(WSAEVENT hEventArr[], int idx, int total);
   void ErrorHandling(char *msg);
   
   int main(int argc, char *argv[])
   {
   	WSADATA wsaData;
   	SOCKET hServSock, hClntSock;
   	SOCKADDR_IN servAdr, clntAdr;
   
   	SOCKET hSockArr[WSA_MAXIMUM_WAIT_EVENTS]; 
   	WSAEVENT hEventArr[WSA_MAXIMUM_WAIT_EVENTS];
   	WSAEVENT newEvent;
   	WSANETWORKEVENTS netEvents;
   
   	int numOfClntSock=0;
   	int strLen, i;
   	int posInfo, startIdx;
   	int clntAdrLen;
   	char msg[BUF_SIZE];
   	
   	if(argc!=2) {
   		printf("Usage: %s <port>\n", argv[0]);
   		exit(1);
   	}
   	if(WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
   		ErrorHandling("WSAStartup() error!");
   
   	hServSock=socket(PF_INET, SOCK_STREAM, 0);
   	servAdr.sin_family=AF_INET;
   	servAdr.sin_addr.s_addr=htonl(INADDR_ANY);
   	servAdr.sin_port=htons(atoi(argv[1]));
   
   	if(bind(hServSock, (SOCKADDR*) &servAdr, sizeof(servAdr))==SOCKET_ERROR)
   		ErrorHandling("bind() error");
   
   	if(listen(hServSock, 5)==SOCKET_ERROR)
   		ErrorHandling("listen() error");
   
   	newEvent=WSACreateEvent();
   	if(WSAEventSelect(hServSock, newEvent, FD_ACCEPT)==SOCKET_ERROR)
   		ErrorHandling("WSAEventSelect() error");
   
   	hSockArr[numOfClntSock]=hServSock;
   	hEventArr[numOfClntSock]=newEvent;
   	numOfClntSock++;
   
   	while(1)
   	{
   		posInfo=WSAWaitForMultipleEvents(
   			numOfClntSock, hEventArr, FALSE, WSA_INFINITE, FALSE);
   		startIdx=posInfo-WSA_WAIT_EVENT_0;
   
   		for(i=startIdx; i<numOfClntSock; i++)
   		{
   			int sigEventIdx=
   				WSAWaitForMultipleEvents(1, &hEventArr[i], TRUE, 0, FALSE);
   			if((sigEventIdx==WSA_WAIT_FAILED || sigEventIdx==WSA_WAIT_TIMEOUT))
   			{
   				continue;
   			}
   			else
   			{
   				sigEventIdx=i;
   				WSAEnumNetworkEvents(
   					hSockArr[sigEventIdx], hEventArr[sigEventIdx], &netEvents);
   				if(netEvents.lNetworkEvents & FD_ACCEPT)
   				{
   					clntAdrLen=sizeof(clntAdr);
   					hClntSock=accept(
   						hSockArr[sigEventIdx], (SOCKADDR*)&clntAdr, &clntAdrLen);
   					newEvent=WSACreateEvent();
   					WSAEventSelect(hClntSock, newEvent, FD_READ|FD_CLOSE);
   
   					hEventArr[numOfClntSock]=newEvent;
   					hSockArr[numOfClntSock]=hClntSock;
   					numOfClntSock++;
   					puts("connected new client...");
   				}
   
   				if(netEvents.lNetworkEvents & FD_READ)
   				{
   					strLen=recv(hSockArr[sigEventIdx], msg, sizeof(msg), 0);
   					SendMsg(hSockArr, numOfClntSock, msg, strLen);
   				}
   
   				if(netEvents.lNetworkEvents & FD_CLOSE)
   				{
   					WSACloseEvent(hEventArr[sigEventIdx]);
   					closesocket(hSockArr[sigEventIdx]);
   					
   					numOfClntSock--;
   					CompressSockets(hSockArr, sigEventIdx, numOfClntSock);
   					CompressEvents(hEventArr, sigEventIdx, numOfClntSock);
   				}
   			}
   		}
   	}
   	WSACleanup();
   	return 0;
   }
   
   void SendMsg(SOCKET clntSocks[], int clntCnt, char * msg, int len)   // send to all
   {
   	int i;
   	for(i=0; i<clntCnt; i++)
   		send(clntSocks[i], msg, len, 0);
   }
   void CompressSockets(SOCKET hSockArr[], int idx, int total)
   {
   	int i;
   	for(i=idx; i<total; i++)
   		hSockArr[i]=hSockArr[i+1];
   }
   void CompressEvents(WSAEVENT hEventArr[], int idx, int total)
   {
   	int i;
   	for(i=idx; i<total; i++)
   		hEventArr[i]=hEventArr[i+1];
   }
   void ErrorHandling(char *msg)
   {	
   	fputs(msg, stderr);
   	fputc('\n', stderr);
   	exit(1);
   }
   

第二十二章 重叠I/O模型

1. 异步通知I/O模型和重叠I/O模型在异步处理方面有哪些区别？

   在异步I/O模型下，以异步的方式处理IO事件发生的过程

   在重叠I/O模型下，还需要异步确认I/O完成的过程

2. 请分析非阻塞I/O、异步I/O、重叠I/O之间的关系

   异步I/O意味着异步处理，确认I/O完成的过程。为了实现这一过程，I/O必须在非阻塞模式下运行。当I/O以非阻塞模式运行并且I/O以异步方式进行时，I/O会重叠

3. 阅读下面代码，指出问题并给出解决方案

   若accpet函数返回失败，WSARecv传入的overlapped会报错，因为overlapped事先没有任何传入。若accept返回成功，因为所有的OVERLAPPED结构都相同，可以使用同一个OVERLAPPED结构体变量给多个WSARecv函数调用

4. 请从源代码角度说明调用WSASend函数后如何验证进入Pending状态

   WSASend函数再返回SOCKET_ERROR的状态下，利用WSAGetLastError函数是否返回WSA_IO_PENDING来验证

5. 线程的"alertable wait状态"的含义是什么？说出能使线程进入这种状态的两个函数

   所谓"alertable wait状态"是指等待接收操作系统信息的状态，在接下来的函数调用中，线程会进入alertable wait状态

   • WaitForSingleObjectEx
   • WaitForMultipleObjectEx
   • WSAWaitForMultipleEvents
   • SleepEx

第二十三章 IOCP

1. 完成端口对象将分配多个线程用于处理I/O。如何创建这些线程？如何分配？请从源码级别进行说明

   Completion Port对象所分摊的线程由程序员创建。这些线程为了确认I/O的完成会调用GetQueuedCompletionStatus函数。虽然任何线程都能调用GetQueuedCompletionStatus函数，但实际得到I/O完成信息的线程数不会超过调用CreateIoCompletionPort函数时指定的最大线程数。

2. CreateIoCompletionPort函数与其他函数不同，提供2种功能。请问是哪2种？

   Completion Port对象的产生，CP对象与套接字进行连接

3. 完成端口对象和套接字之间的连接意味着什么？如何连接？

   首先通过CreateIoCompletionPort生成CP对象。之后再次使用CreateIoCompletionPort函数将CP对象与套接字进行连接。

4. cd

5. √ √ ×

6. 代码

   #include <stdio.h>
   #include <stdlib.h>
   #include <process.h>
   #include <winsock2.h>
   #include <windows.h>
   
   #define BUF_SIZE 100
   #define MAX_CLNT 256
   #define READ	3
   #define	WRITE	5
   
   typedef struct    // socket info
   {
   	SOCKET hClntSock;
   	SOCKADDR_IN clntAdr;
   } PER_HANDLE_DATA, *LPPER_HANDLE_DATA;
   
   typedef struct    // buffer info
   {
   	OVERLAPPED overlapped;
   	WSABUF wsaBuf;
   	char buffer[BUF_SIZE];
   } PER_IO_DATA, *LPPER_IO_DATA;
   
   DWORD WINAPI EchoThreadMain(LPVOID CompletionPortIO);
   void SendMsg(char * msg, DWORD len);
   void ErrorHandling(char *message);
   
   int clntCnt=0;
   SOCKET clntSocks[MAX_CLNT];
   
   int main(int argc, char* argv[])
   {
   	WSADATA	wsaData;
   	HANDLE hComPort;	
   	SYSTEM_INFO sysInfo;
   	LPPER_IO_DATA ioInfo;
   	LPPER_HANDLE_DATA handleInfo;
   
   	SOCKET hServSock;
   	SOCKADDR_IN servAdr;
   	int recvBytes, i, flags=0;
   
   	if(WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
   		ErrorHandling("WSAStartup() error!"); 
   
   	hComPort=CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
   	GetSystemInfo(&sysInfo);
   
   	for(i=0; i<sysInfo.dwNumberOfProcessors; i++)
   		_beginthreadex(NULL, 0, EchoThreadMain, (LPVOID)hComPort, 0, NULL);
   
   	hServSock=WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
   	servAdr.sin_family=AF_INET;
   	servAdr.sin_addr.s_addr=htonl(INADDR_ANY);
   	servAdr.sin_port=htons(atoi(argv[1]));
   
   	bind(hServSock, (SOCKADDR*)&servAdr, sizeof(servAdr));
   	listen(hServSock, 5);
   	
   	while(1)
   	{	
   		SOCKET hClntSock;
   		SOCKADDR_IN clntAdr;		
   		int addrLen=sizeof(clntAdr);
   		
   		hClntSock=accept(hServSock, (SOCKADDR*)&clntAdr, &addrLen);
   		clntSocks[clntCnt++]=hClntSock;
   
   		handleInfo=(LPPER_HANDLE_DATA)malloc(sizeof(PER_HANDLE_DATA));		
   		handleInfo->hClntSock=hClntSock;
   		memcpy(&(handleInfo->clntAdr), &clntAdr, addrLen);
   
   		CreateIoCompletionPort((HANDLE)hClntSock, hComPort, (DWORD)handleInfo, 0);
   		
   		ioInfo=(LPPER_IO_DATA)malloc(sizeof(PER_IO_DATA));
   		memset(&(ioInfo->overlapped), 0, sizeof(OVERLAPPED));		
   		ioInfo->wsaBuf.len=BUF_SIZE;
   		ioInfo->wsaBuf.buf=ioInfo->buffer;
   
   		WSARecv(handleInfo->hClntSock,	&(ioInfo->wsaBuf),	
   			1, &recvBytes, &flags, &(ioInfo->overlapped), NULL);			
   	}
   	return 0;
   }
   
   DWORD WINAPI EchoThreadMain(LPVOID pComPort)
   {
   	HANDLE hComPort=(HANDLE)pComPort;
   	SOCKET sock;
   	DWORD bytesTrans;
   	LPPER_HANDLE_DATA handleInfo;
   	LPPER_IO_DATA ioInfo;
   	DWORD flags=0;
   	int i;
   	
   	while(1)
   	{ 
   		GetQueuedCompletionStatus(hComPort, &bytesTrans, 
   			(LPDWORD)&handleInfo, (LPOVERLAPPED*)&ioInfo, INFINITE);
   		sock=handleInfo->hClntSock;
   
   		puts("message received!");
   		if(bytesTrans==0)    // EOF
   		{
   			for(i=0; i<clntCnt; i++)   // remove disconnected client
   			{
   				if(sock==clntSocks[i])
   				{
   					while(i++<clntCnt-1)
   					clntSocks[i]=clntSocks[i+1];
   					break;
   				}
   			}
   			clntCnt--;
   
   			closesocket(sock);
   			free(handleInfo); free(ioInfo);
   			continue;		
   		}
   
   		SendMsg(ioInfo->buffer, bytesTrans);
   
   		memset(&(ioInfo->overlapped), 0, sizeof(OVERLAPPED));			
   		WSARecv(sock, &(ioInfo->wsaBuf), 
   			1, NULL, &flags, &(ioInfo->overlapped), NULL);
   	}
   	return 0;
   }
   
   void SendMsg(char * msg, DWORD len)   // send to all
   {
   	int i;
   	for(i=0; i<clntCnt; i++)
   		send(clntSocks[i], msg, len, 0);
   }
   void ErrorHandling(char *message)
   {
   	fputs(message, stderr);
   	fputc('\n', stderr);
   	exit(1);
   }
   

第二十四章 制作HTTP服务器端

1. abe

2. a

3. IOCP和epoll是可以保证高性能的典型服务器端模型，但如果在基于HTTP协议的Web服务器端使用这些模型，则无法保证一定能得到高性能。请说明原因

   IOCP和epoll都是可以管理两个以上socket的服务器模型。即在称为观察对象的端口中，感知与IO相关的事件发生的端口，并处理相关的I/O服务器模式。如实对网络服务器来说，并不要管理两个以上的socket。因为只要完成一次请求和回答的过程，连接就会结束。因此，用IOCP和epoll提高性能，有一定的局限性