关于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)成立。