孙鑫MFC笔记教程(16)--线程同步和异步套接字编程

线程同步有三种方式：

1. 互斥对象涉及方法：

HANDLE hMutex=CreateMutex(NULL,FALSE,NULL); //第二个参数为FALSE,将互斥对象声明为空闲状态

WaitForSingleObject(hMutex,INFINITE); //第二个参数为INFINITE表示一直等待，直到拥有互斥对象

ReleaseMutex(hMutex); //使用完了，将互斥对象还给操作系统

具体代码及各种情况的分析见上一章，这里就不再叙述。

2. 事件对象：

事件对象也属于内核对象，包含一个使用计数，一个用于指明该事件是一个自动重置的事件还是一个人工重置的事件的布尔值，另一个用于指明该事件处于可用状态还是不可用的布尔值。

有两种不同类型的事件对象。一种是人工重置的事件，另一种是自动重置的事件。当人工重置的事件得到通知时，等待该事件的所有线程均变为可调度线程。当一个自动重置的事件得到通知时，等待该事件的线程中只有一个线程变为可调度线程。所以优先选择自动重置的事件。

说明：CreateEvent方法第一个参数是关于的安全的结构体，一般设置为NULL；第二个参数表示是人工重置还是自动重置，TRUE代表人工重置，如果为TURE需要调用这个ResetEvent函数来人工重置为非信号状态；第三个参数表示初始化状态，如果为TURE初始化状态信号为有信号的；第四个参数表示Event名称，NULL的话，默认。

BOOL ResetEvent(
HANDLE hEvent // handle to event
);

BOOL SetEvent(
HANDLE hEvent // handle to event
);//设置信号为有信号状态

HANDLE g_hEvent=CreateEvent(NULL,TRUE,FALSE,NULL);

以下代码会出现异常：在将CreateEvent的第二个参数设置为人工重置的时候，因为等待该事件的所有线程均变为可调度线程，所以发现售票实例程序最终会出现0。所以最好还是选择自动重置的事件。

#include <windows.h>

#include <iostream.h>

DWORD WINAPI ThreadProc1(LPVOID lpParameter);

DWORD WINAPI ThreadProc2(LPVOID lpParameter);

int ticket=100;

HANDLE g_hEvent;

void main()

{

g_hEvent=CreateEvent(NULL,TRUE,TRUE,NULL);//初始化代码应放在创建线程以前

HANDLE handle1=CreateThread(NULL,0,ThreadProc1,NULL,0,NULL);

HANDLE handle2=CreateThread(NULL,0,ThreadProc2,NULL,0,NULL);

CloseHandle(handle1);

CloseHandle(handle2);

g_hEvent=CreateEvent(NULL,TRUE,TRUE,NULL);//放在最前面

Sleep(4000);

CloseHandle(g_hEvent);

}

DWORD WINAPI ThreadProc1(LPVOID lpParameter)

{

while(TRUE)

{

WaitForSingleObject(g_hEvent,INFINITE); //第二个参数为INFINITE表示一直等待，直到拥有互斥对象

if(ticket>0)

{

Sleep(1);

cout<<"thread1 sale the ticket id is:"<<ticket--<<endl;

}

else

break;

}

return 0;

}

DWORD WINAPI ThreadProc2(LPVOID lpParameter)

{

while(TRUE)

{

WaitForSingleObject(g_hEvent,INFINITE);

if(ticket>0)

{

Sleep(1);

cout<<"thread2 sale the ticket id is:"<<ticket--<<endl;

}

else

break;

}

return 0;

}

说明：

如果一个线程循环内部已经调用了WaitForSingleObject(g_hEvent,INFINITE);但是在单个循环完成前没有调用SetEvent(g_hEvent)将状态设置成可用的话，下一次进入循环时再次调用WaitForSingleObject时发现状态不可用，所以一直等待，代码例子将上面的代码g_hEvent=CreateEvent(NULL,TRUE,TRUE,NULL);修改为g_hEvent=CreateEvent(NULL,FALSE,TRUE,NULL);则会出现这个问题，其结果就是仅仅线程1售出了100这张票。如果在循环退出前调用SetEvent(g_hEvent);则问题可以解决。

综上所述，涉及到的方法：

HANDLE g_hEvent=CreateEvent(NULL,TRUE,FALSE,NULL);

WaitForSingleObject(g_hEvent,INFINITE); //等待事件，如果事件可用，运行下面的代码，并且将事件状态设置为不可用状态，如果事件不可用，一直等待。

SetEvent(g_hEvent) //将事件设置为可用的状态

ResetEvent(g_hEvent) //将事件设置为不可用状态

一般情况下WaitForSingleObject和SetEvent配对使用。

3. 关键代码段：

关键代码段(临界区)是指一个小代码段，在代码能够执行前，它必须独占对某些资源的访问权。

可以将关键代码段想象成电话亭资源：

CRITICAL_SECTION g_cs;

InitializeCriticalSection(&g_cs); //创建电话亭资源，一般放在构造函数中

EnterCriticalSection(&g_cs); //判断关键资源所有权是否可用，可用则进入

LeaveCriticalSection(&g_cs）；使用完关键资源后，释放所有权

DeleteCriticalSection(&g_cs); //销毁电话亭资源，一般放在析构函数中

其中InitializeCriticalSection和DeleteCriticalSection配对使用；

EnterCriticalSection和LeaveCriticalSection配对使用，中间存放访问共享资源的代码。

4. 互斥对象、事件对象与关键代码段的比较

互斥对象和事件对象属于内核对象，利用内核对象进行线程同步，速度较慢，但利用互斥对象和事件对象这样的内核对象，可以在多个进程中的各个线程间进行同步。

关键代码段是工作在用户方式下，同步速度较快，但在使用关键代码段时，很容易进入死锁状态，因为在等待进入关键代码段时无法设定超时值。

5. 死锁：

哲学家进餐的问题：每个哲学家手中只有一根筷子，要进餐必须有两根，但谁也不愿意先给出自己的那根给别人。大家都处于等待状态。

线程1拥有了临界区对象A，等待临界区对象B的拥有权，线程2拥有了临界区对象B，等待临界区对象A的拥有权，就造成了死锁。

死锁代码：

#include <windows.h>

#include <iostream.h>

DWORD WINAPI ThreadProc1(LPVOID lpParameter);

DWORD WINAPI ThreadProc2(LPVOID lpParameter);

int ticket=100;

//创建两个关键资源

CRITICAL_SECTION g_cs1;

CRITICAL_SECTION g_cs2;

void main()

{

HANDLE handle1=CreateThread(NULL,0,ThreadProc1,NULL,0,NULL);

HANDLE handle2=CreateThread(NULL,0,ThreadProc2,NULL,0,NULL);

CloseHandle(handle1);

CloseHandle(handle2);

InitializeCriticalSection(&g_cs1);//初始化要放在前面

InitializeCriticalSection(&g_cs2);

Sleep(4000);

DeleteCriticalSection(&g_cs1);

DeleteCriticalSection(&g_cs2);

}

DWORD WINAPI ThreadProc1(LPVOID lpParameter)

{

while(TRUE)

{

EnterCriticalSection(&g_cs1);

Sleep(1);

EnterCriticalSection(&g_cs2);

if(ticket>0)

{

Sleep(1);

cout<<"thread1 sale the ticket id is:"<<ticket--<<endl;

}

else

break;

LeaveCriticalSection(&g_cs1);

LeaveCriticalSection(&g_cs2);

}

return 0;

}

DWORD WINAPI ThreadProc2(LPVOID lpParameter)

{

while(TRUE)

{

EnterCriticalSection(&g_cs2);

Sleep(1);

EnterCriticalSection(&g_cs1);

if(ticket>0)

{

Sleep(1);

cout<<"thread2 sale the ticket id is:"<<ticket--<<endl;

}

else

break;

LeaveCriticalSection(&g_cs1);

LeaveCriticalSection(&g_cs2);

}

return 0;

}

说明：首先线程1得到资源1的所有权，然后睡眠1毫秒，线程1就让出了执行权，这个时候线程2得到执行权，运行，得到资源2的所有权，线程2然后睡眠1毫秒，线程2就让出了执行权，这个时候线程1得到执行权，线程1继续执行，想得到资源2的资源，但发现资源2被线程1所占用，等待。当线程1的事件片过了以后，线程2得到执行权，继续执行，想得到资源1的所有权，但发现资源1被线程1占用，所以也继续等待，这样线程1和线程2都互相等待，造成死锁。

1. 异步套接字编程：
Windows套接字在两种模式下执行I/O操作，阻塞和非阻塞。在阻塞模式下，在I/O操作完成前，执行操作的Winsock函数会一直等待下去，不会立即返回程序(将控制权交还给程序)。而在非阻塞模式下，Winsock函数无论如何都会立即返回。采用异步套接字，可有效改善程序的运行性能。
Windows Sockets为了支持Windows消息驱动机制，使应用程序开发者能够方便地处理网络通信，它对网络事件采用了基于消息的异步存取策略。
Windows Sockets的异步选择函数WSAAsyncSelect()提供了消息机制的网络事件选择，当使用它登记的网络事件发生时，Windows应用程序相应的窗口函数将收到一个消息，消息中指示了发生的网络事件，以及与事件相关的一些信息。
在上一章中编写的Chat程序中，因为接收程序放在了一个线程中，所以虽然它是阻塞的，也没有影响到主线程的运行性能。
2. 编写基于异步套接字的聊天室程序：

相关函数：
int WSAEnumProtocols( LPINT lpiProtocols, LPWSAPROTOCOL_INFO lpProtocolBuffer, ILPDWORD lpdwBufferLength );
Win32平台支持多种不同的网络协议，采用Winsock2，就可以编写可直接使用任何一种协议的网络应用程序了。通过WSAEnumProtocols函数可以获得系统中安装的网络协议的相关信息。
lpiProtocols，一个以NULL结尾的协议标识号数组。这个参数是可选的，如果lpiProtocols为NULL，则返回所有可用协议的信息，否则，只返回数组中列出的协议信息。
lpProtocolBuffer，[out]，一个用WSAPROTOCOL_INFO结构体填充的缓冲区。 WSAPROTOCOL_INFO结构体用来存放或得到一个指定协议的完整信息。
lpdwBufferLength，[in, out]，在输入时，指定传递给WSAEnumProtocols()函数的lpProtocolBuffer缓冲区的长度；在输出时，存有获取所有请求信息需传递给WSAEnumProtocols ()函数的最小缓冲区长度。这个函数不能重复调用，传入的缓冲区必须足够大以便能存放所有的元素。这个规定降低了该函数的复杂度，并且由于一个 机器上装载的协议数目往往是很少的，所以并不会产生问题。

SOCKET WSASocket( int af, int type, int protocol, LPWSAPROTOCOL_INFO lpProtocolInfo, GROUP g, DWORD dwFlags );
前三个参数和socket()函数的前三个参数含义一样。
lpProtocolInfo，一个指向WSAPROTOCOL_INFO结构体的指针，该结构定义了所创建的套接字的特性。如果lpProtocolInfo为NULL，则WinSock2 DLL使用前三个参数来决定使用哪一个服务提供者，它选择能够支持规定的地址族、套接字类型和协议值的第一个传输提供者。如果lpProtocolInfo不为NULL，则套接字绑定到与指定的结构WSAPROTOCOL_INFO相关的提供者。
g，保留的。
dwFlags，套接字属性的描述。

a. 因为MFC自带的AfxSocketInit函数初始化支持的是1.1版本的套接字，不适合异步套接字，我们需要调用的是Winsock2版本的套接字，那么加载套接字库的过程只能使用WSAStartup了。在CChatApp的InitInstance初始化函数中添加：

WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD( 2, 2 );
err = WSAStartup( wVersionRequested, &wsaData );
if ( err != 0 ) {
return;
}
if ( LOBYTE( wsaData.wVersion ) != 2 ||
HIBYTE( wsaData.wVersion ) != 2 ) {
WSACleanup( );
return;
}
b. 在StdAfx.h里添加#include <winsock2.h>，在setting里添加ws2_32.lib库文件。
c. 给CChatApp类添加析构函数，在其中添加WSACleanup来终止对套接字库的使用。
d. 给CChatDlg类添加成员变量SOCKET m_socket，并在构造函数中初始化为0
e. 给CChatDlg类添加析构函数，添加:
if(m_socket) //判断socket是否有值
closesocket(m_socket);
f. 创建初始化函数InitSocket()，代码如下：
说明：在Winsock2版本中提供的WSASocket这样一个扩展方法用于创建套接字，对应于socket方法；bind方法在winsock2中没有提供相应的扩展方法。然后调用WSAAsyncSelect方法请求一个windows基于消息的网络事件通知。
m_socket=WSASocket(AF_INET,SOCK_DGRAM,0,NULL,0,0);
if(INVALID_SOCKET==m_socket)
{
MessageBox("创建套接字失败！");
return FALSE;
}

SOCKADDR_IN addrSock;
addrSock.sin_addr.S_un.S_addr=htonl(INADDR_ANY);
addrSock.sin_family=AF_INET;
addrSock.sin_port=htons(1234);

int retVal;
retVal=bind(m_socket,(SOCKADDR*)&addrSock,sizeof(SOCKADDR));
if(SOCKET_ERROR==retVal)
{
MessageBox("套接字绑定失败！");
return FALSE;
}
说明：WSAAsyncSelect方法第二个参数表示网络事件发生时用来接收消息的窗口，第三个参数表示处理响应的消息，第四个参数表示网络事件类型，采用或操作。我们当前采用读这样一个事件，网络上一旦有数据到来的时候就会触发这个事件，系统就会通过我们自定义的消息UM_SOCK来通知我们进行处理if(SOCKET_ERROR==WSAAsyncSelect(m_socket,m_hWnd,UM_SOCK,FD_READ))
{
MessageBox("注册网络读取事件失败！");
return FALSE;
};
return TRUE;
g. 消息响应函数的处理：
1. 创建自定以的消息UM_SOCK，注意：在消息响应函数的申明中还是要添加WPARAM和LPARAM参数，因为网络上的数据是通过这两个参数传递给消息响应函数进行处理的。
2. 参看MSDN中WSAAsyncSelect方法的说明如下：
When one of the nominated network events occurs on the specified socket s, the application's window hWnd receives message wMsg. The wParam parameter identifies the socket on which a network event has occurred. The low word of lParam specifies the network event that has occurred. The high word of lParam contains any error code.
3. WSARecvFrom函数的第二个参数可表示一个WSABUF的结构体数组，可用于存放多个从网络上接收到的信息块，当然也可以将所有信息放在一个结构体中，然后将自己关心的信息块取出，但这样做比较麻烦，可以直接用WSABUF结构体数组接收不同信息的块即可。（没有具体的实际操作经验）
在消息响应函数中添加如下代码

int WSARecvFrom( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesRecvd, LPDWORD lpFlags, struct sockaddr FAR *lpFrom, LPINT lpFromlen, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine );
s，标识套接字的描述符。
lpBuffers，[in, out]，一个指向WSABUF结构体的指针。每一个WSABUF结构体包含一个缓冲区的指针和缓冲区的长度。
typedef struct __WSABUF {
u_long len;
char FAR *buf;
} WSABUF, FAR * LPWSABUF;

dwBufferCount， lpBuffers数组中WSABUF结构体的数目。
lpNumberOfBytesRecvd，[out]，如果接收操作立即完成，则为一个指向本次调用所接收的字节数的指针。
lpFlags，[in, out]，一个指向标志位的指针。
lpFrom，[out]，可选指针，指向重叠操作完成后存放源地址的缓冲区。
lpFromlen，[in, out]，指向from缓冲区大小的指针，仅当指定了lpFrom才需要。
lpOverlapped，一个指向WSAOVERLAPPED结构体的指针(对于非重叠套接字则忽略)。
lpCompletionRoutine，一个指向接收操作完成时调用的完成例程的指针(对于非重叠套接字则忽略)。

switch(LOWORD(lParam)) { //lParam的低字节指明网络事件的类型
case FD_READ: //我们当前只有读取这样一个事件，这是在WSAAsyncSelect中设定的
WSABUF wsabuf;
wsabuf.buf=new char[200]; //网络上接收到的数据
wsabuf.len=200;
DWORD dwRead;
DWORD dwFlag=0;
SOCKADDR_IN addrFrom;
int len=sizeof(addrFrom);
CString str;
if(SOCKET_ERROR==WSARecvFrom(m_socket,&wsabuf,1,&dwRead,&dwFlag,(SOCKADDR*)&addrFrom,&len,NULL,NULL))
{
//下面的消息框基本不会运行，因为WSARecvFrom方法是在有网络数据的情况下才会被调用的，所以运行到这段，基本是有数据的，做这样一个判断，只是出于编程风格一致而已
MessageBox("接收数据失败！");
return;
}
str.Format("from %s said:%s",inet_ntoa(addrFrom.sin_addr),wsabuf.buf);
CString temp;
GetDlgItemText(IDC_EDIT_RECV,temp);
temp+="/r/n"+str;
SetDlgItemText(IDC_EDIT_RECV,temp);
break;
}
h. 信息的发送：

int WSASendTo( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesSent, DWORD dwFlags, const struct sockaddr FAR *lpTo, int iToLen, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine );
s，标识一个套接字(可能已连接)的描述符。
lpBuffers，一个指向WSABUF结构体的指针。每一个WSABUF结构体包含一个缓冲区的指针和缓冲区的长度。
dwBufferCount， lpBuffers数组中WSABUF结构体的数目。
lpNumberOfBytesSent，[out]，如果发送操作立即完成，则为一个指向本次调用所发送的字节数的指针。
dwFlags，指示影响操作行为的标志位。
lpTo，可选指针，指向目标套接字的地址。
iToLen，lpTo中地址的长度。
lpOverlapped，一个指向WSAOVERLAPPED结构的指针(对于非重叠套接字则忽略)。
lpCompletionRoutine，一个指向接收操作完成时调用的完成例程的指针(对于非重叠套接字则忽略)。

DWORD dwIP; //控件上填写的IP地址
CString strSend; //需要发送的信息内容
WSABUF wsbuf; //需要发送的信息内容
DWORD dwSend;
((CIPAddressCtrl*)GetDlgItem(IDC_IPADDRESS1))->GetAddress(dwIP);
GetDlgItemText(IDC_EDIT_SEND,strSend);

SOCKADDR_IN addrTo;
addrTo.sin_addr.S_un.S_addr=htonl(dwIP);
addrTo.sin_family=AF_INET;
addrTo.sin_port=htons(1234);

//GetBuffer函数将CString类型转换为char*类型
wsbuf.buf=strSend.GetBuffer(strSend.GetLength());
wsbuf.len=strSend.GetLength()+1; //多一个字节用于存放结束操作符
if(SOCKET_ERROR==WSASendTo(m_socket,&wsbuf,1,&dwSend,0,(SOCKADDR*)&addrTo,sizeof(SOCKADDR),NULL,NULL))
{
MessageBox("发送数据失败!");
return;
}
else
{
SetDlgItemText(IDC_EDIT_SEND,"");
}
i. 综上所述，创建一个基于winsock2版本的异步套接字的网络聊天室程序有以下几个步骤：
1. 调用WSAStartup加载套接字库
2. 调用WSASocket创建套接字
3. 调用WSAAsyncSelect请求基于windows消息的网络事件通知
4. 创建自定义的消息响应函数，来处理捕获的网络事件
5. 在消息响应函数内部调用WSARecvFrom来处理接收到的数据
6. 调用WSASendTo处理发送数据

3.通过主机名称实现聊天：
//IP转换为主机名称
//str.Format("from %s said:%s",inet_ntoa(addrFrom.sin_addr),wsabuf.buf);修改为以下代码
HOSTENT *pHost;
pHost = gethostbyaddr((char*)&addrFrom.sin_addr.S_un.S_addr,4,AF_INET);
str.Format("from %s said:%s",pHost->h_name,wsabuf.buf);

//主机名称转换为IP
HOSTENT * pHost;
SOCKADDR_IN addrTo;
CString strHostName;

if (GetDlgItemText(IDC_EDIT_HOSTNAME,strHostName),strHostName=="")
{
((CIPAddressCtrl*)GetDlgItem(IDC_IPADDRESS1))->GetAddress(dwIP);
addrTo.sin_addr.S_un.S_addr=htonl(dwIP);
}
else
{
pHost = gethostbyname(strHostName);
addrTo.sin_addr.S_un.S_addr=*((DWORD*)pHost->h_addr_list[0]);
}

4. 小结：
当前程序将消息的接收和发送放在了同一个线程中，即主线程中。如果采用先前使用过的阻塞套接字的话，程序会因为接收函数的调用导致主线程的暂停运行，就无法及时的发送消息了。但是采用异步套接字可使得发送和接收放在同一个线程中而不会有相互的影响。
如果采用异步套接字加上多线程编程，则大大会提高网络运用程序的性能。
在第十四课中讲winsock1.1的编程中一般将接收函数放在一个while循环中，来使得程序一直处于接收响应状态，在异步套接字中，利用了在程序初始化的时候调用了WSAAsyncSelect方法来声明程序的网络的事件有相应的自定义消息来处理，其真正的核心部分还是封装在MFC中
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/roger_ge/archive/2008/09/09/2903337.aspx