关于socket的Accept阻塞模式的退出方法分析

众所周知，socket的Accept会阻塞当前线程。如果子程序，或者类在被回收时，没有正确的中止socket，则会引发一些异常。我说下常用的一些处理方法：

1.强行中断线程。

    这种方法我觉得是最差的，因为强行中断正在执行的线程，可能会引发一些意想不到的结果，这是最差的方法。

2.在Socket上调用Pending()方法。

    这种做法的原理就是：

       a.看Socket是否有连接请求。如果没有，则返回失败

       b.失败后调用Sleep方法等待线程，然后再循环到a

    我认为，这也不是一种好的办法，相当于人工进行了可控制的等待，Accept本来就有阻塞功能，这样做不是多此一举吗？

3.在.net程序中用异常捕捉法，如下代码所示：

public void init(int nProt = 9988)
{
    tlTcpListen = new TcpListener(IPAddress.Parse("127.0.0.1"), nProt);
    tlTcpListen.Start();
    Thread client = new Thread(new ThreadStart(DoListen));
    client.Start();
}

static void DoListen()
{
    try
    {
	//if (!tlTcpListen.Pending())
	TcpClient tcpClient = tlTcpListen.AcceptTcpClient();
	Debug.WriteLine("有连接进入");
	int id = Thread.CurrentThread.ManagedThreadId;
	info.Add(Thread.CurrentThread.ManagedThreadId, tcpClient);

    }
    catch (ObjectDisposedException)
    {
;
    }
    catch (SocketException socketException)
    {
	if (socketException.ErrorCode == (int)SocketError.Interrupted)
	{
   		 Debug.WriteLine("已取消阻止 System.Net.Sockets.Socket 调用的操作。");
    		return;
	}
	Debug.WriteLine("有错误发生，代码为" + socketException.ErrorCode.ToString());
    }
}
public void Dispose()
{
    if (tlTcpListen != null)tlTcpListen.Stop();
}

  在CSDN的论坛中我看到有人说，用异常捕捉总给人感觉不好。但是如果你查一下文档，就会发现SocketError.Interrupted是很正常的状态，大可不必介意。
其实C++也是这么做的，但是不会出异常。
相应的代码如下，我也给出来代大家参考，希望能消除大家心里对.net 异常处理的各种不爽

bool NetWorkGate::init(UINT nPort)
{
	//启动套接字
	WSADATA wsaData;
	//ZeroMemory(&wsaData,sizeof(WSADATA));
	if (WSAStartup(MAKEWORD(1,1),&wsaData))
	{
		TRACE(_T("初始化sock失败\n"));
		return false;
	}

	m_ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (m_ListenSocket == INVALID_SOCKET)
	{
		TRACE(_T("创建监听sock失败\n"));
		return false;
	}
	//端口绑定
	SOCKADDR_IN local;
	local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
	local.sin_family = AF_INET;
	local.sin_port = htons(nPort);
	if (bind(m_ListenSocket, (sockaddr *)&local, sizeof(SOCKADDR_IN)) == SOCKET_ERROR)
	{
		closesocket(m_ListenSocket);
		m_ListenSocket = INVALID_SOCKET;
		return false;
	}
	listen(m_ListenSocket,5);
	CWinThread* thread = AfxBeginThread(BeginAccept,(LPVOID)m_ListenSocket);//启动线程来监听，避免阻塞
	return true;
}

void NetWorkGate::stop(void)
{
	if (m_ListenSocket != INVALID_SOCKET)
	{

		shutdown(m_ListenSocket, SD_BOTH);
		closesocket(m_ListenSocket);
		while (m_count > 0)
		{
			Sleep(100);
		}
	}
	return;
}
//线程，用来阻塞sock，监听并等待连接
UINT NetWorkGate::BeginAccept(LPVOID pParam)
{
	using namespace std;
	list<SOCKET> lst_socket ;
	while (true)
	{
		TRACE(_T("\n正在等待客户端的接入\n"));
		sockaddr_in remote_addr;
		int addr_len = sizeof(sockaddr);
		printf("accept start\n");
		SOCKET sock = accept((SOCKET)pParam, (sockaddr *)&remote_addr, &addr_len);
		if (INVALID_SOCKET == sock)
		{
			TRACE(_T("网络连接被断开，线程将会返回。。\n"));
			list<SOCKET>::iterator i;
			for (i = lst_socket.begin(); i != lst_socket.end(); ++i)
			{
				shutdown(*i, SD_BOTH);
				closesocket(*i);
			}
			//关闭所有客户端的连接
			return 0;
		} 
		else
		{
			TRACE(_T("客户连接成功\n"));
			lst_socket.push_back(sock);
			m_count++;
			//在这里可进账号验证，如果验证成功就会启动新的线程进行消息分发。
			//保存sock，以备后续进行关闭。
			AfxBeginThread(StartNewClient,(LPVOID)sock);
		}
	}
	return 0;
}
//线程的线程，每个客户端都会建立一个新的连接
UINT NetWorkGate::StartNewClient(LPVOID pParam)
{
	int iResult =0;
	SOCKET sock = (SOCKET)pParam;
	while (true)
	{
		TRACE(_T("--新的客户端被接受，正在等待消息--\n"));
		char recvBuf[50]={0};
		iResult=recv(sock,recvBuf,50,0); 
		if ( iResult > 0 )
		{
			TCHAR szBuf[50]={0};
			swprintf_s(szBuf , _T("%s") , recvBuf);
			TRACE(_T("--收到来自客户端的消息：%s\n"),szBuf);
			send(sock, (const char *)_T("abcdef") , 10 ,0 );
		}
		else
		{
			if ( iResult == 0 ) TRACE(_T("--网络连接断开--\n"));
			else TRACE(_T("--错误：%d\n"),WSAGetLastError());
			m_count--;
			return 0;
		}
	}
	return 0;
}

从C++代码我们可以看出，.net的处理方式 与C++的处理方式 是一样的。只不过.net在监听被关闭而socket被阻时，会抛出错误，C++则会(INVALID_SOCKET == sock)成立。


欢迎拍砖