Windows Socket 非阻塞模式开发

最新推荐文章于 2024-05-13 13:58:56 发布
最新推荐文章于 2024-05-13 13:58:56 发布
阅读量8.7k 收藏 26
点赞数 1
分类专栏： 网络 文章标签： windows socket

转载自：http://blog.youkuaiyun.com/ithzhang/article/details/8274596

非阻塞套接字

非阻塞模式是指：套接字在执行操作时，调用的函数不管操作是否完成都会立即返回的工作模式。

非阻塞套接字在处理同时建立的多个连接等方面具有明显的优势。但是使用过程中有一定的难度。由于函数在操作没有完成后也仍然会返回，为了实现某些功能必须循环调用，直到完成功能为止。因此非阻塞模式会使程序效率非常低。

把套接字设置为非阻塞模式，即告诉系统：在调用 Windows socket API 时，不让主调线程睡眠，而让函数立即返回。比如在调用 recv 函数时，即使此时接受缓冲区没有数据，也不会导致线程在 recv 处等待， recv 函数会立即返回。如果没有调用成功函数会返回 WSAEROULDBLOCK 错误代码。为了接收到数据必须循环调用 recv ,这也是非阻塞与阻塞模式的主要区别。

默认情况下，使用 socket 或是 WSASocket 函数创建的套接字都是阻塞的。在创建套接字之后可以调用 ioctsocket 函数将套接字设置为非阻塞模式。

SOCKET s;
unsigned long ul=1;
int ret;
s = socket(AF_INET,SOCK_STREAM,0);

ret=ioctlsocket(s,FIONBIO,(unsigned long *)&ul);    //设置成非阻塞模式
if(ret==SOCKET_ERROR)   //设置失败
{
}

//如果Windows socket api函数在返回时，却没有完成功能，它将返回WSAEWOULDBLOCK错误代码。
//说明请求的操作在调用期间内没有完成。通常情况下应用程序需要重复调用此函数直到返回值标识为成功为止。  
while(true)
{
    ret = recv(s, buff, num, 0);
    if(ret == SOCKET_ERROR)
    {
        err = WSAGetLastError();
        if(err == WSAEWOULDBLOCK)
        {
            continue;
        }
        else if(err==WSAETIMEDOUT)//超时
        {
        }
        else if(err==WSAENETDOWN)//连接断开
        {
        }
        else  //其他错误
        {
            break;
        }
    }
    else
    {
        break;  //接受成功
    }
}

在上面的代码中， WSAGetLastError 函数返回 WSAEWOULDBLOCK 错误码时，说明此时套接字缓冲区还没有数据。需要继续调用。除了 WSAEWOULDBLOCK 错误码之外，还有 WSAETIMEDOUT 和 WSAENETDOWN 错误，这些错误说明由于网络原因，与对方已经断开了连接。

不同的 Windows socket api 虽然都返回 WSAEWOULDBLOCK 但是它们所表示的错误原因却不尽相同:
  accept 和 WSAAccept， WSAEWOULDBLOCK    表示没有收到连接请求。
  recv 和 WSARecv、recvfrom、WSARecvfrom    表示接受缓冲区没有收到数据。
  send、WSASend、sendfrom 和 WSASendfrom   标识发送缓冲区不可用。
  connecte、WSAConnect              表示连接未能立即完成。

以上这些函数，在未完成任务时都会返回 WSAEWOULDBLOCK，但是 bind 和 WSAStartup 函数，却不会返回该错误代码。除了调用 ioctlsocket函数，将套接字设置为非阻塞模式之外，还可以调用 WSAAsyncSelect 和 WSAEventselect 函数。这会在后面介绍。

由于使用非阻塞套接字，函数会频繁返回 WSAEWOULDBLOCK 错误。因此任何时候都应该仔细检查返回代码。

看一个完整的例子：该例分为服务器程序和客户端程序。客户端向服务器发送任意一段话，服务器在接收到时会返回给客户端当前时间和日期。客户端和服务器都采用非阻塞套接字实现。

服务器程序：

服务器程序：由主线程、接受客户端请求线程、接收数据线程和发送数据线程。

主线程负责显示界面，创建其他线程，同时初始化 socket 库、创建 socket 监听端口等基本操作。由于不知道客户端何时会发起连接，因此需要不停的循环调用 accept ，当有客户端连接到来时，接受客户端的连接请求。为了提高性能，创建一个新的线程来执行此操作。此线程为接受客户端请求线程。

由于 recv 和 send 函数，在未完成任务时也会返回。因此需要循环调用它们，直到执行成功为止。同样为了提高性能，我们也分别创建两个线程用于循环调用 recv 和 send，接收和发送数据。注意由于每一个连接都既可以发送又可以接受数据，因此为每个连接都创建了这两个线程。为了便于管理，我们为将创建一个类，每个连接都是该类的对象。每个连接都包括接收线程和发送线程。

CClient 类头文件( Client.h )。CClient 类管理每个连接。

#pragma once

#include<iostream>
#include"windows.h"
#include"time.h"

class CClient
{
public:
    CClient(void);
    CClient(SOCKET s,sockaddr_in addr);
    ~CClient(void);

public:
    bool IsConnected();//判断连接是否中断。
    bool DisConnect();//中断与服务器的连接。
    bool calc();//计算当前时间，并复制到发送缓冲区内。
    bool startRunning();//开始运行发送和接收线程。

    static DWORD WINAPI sendThread(void*param);//发送线程入口函数。
    static DWORD WINAPI recvThread(void*param);//接收线程入口函数。

private:
    HANDLE m_hSendThread;//发送线程句柄。
    HANDLE m_hRecvThread;//接受线程句柄。
    HANDLE m_hEvent;//发送线程和接收线程同步事件对象。接收客户端请求后通知发送线程发送当前时间。

    SOCKET m_socket;//与客户端连接套接字。
    sockaddr_in m_addr;//客户端地址。

    bool m_IsConnected;
    char *m_pRecvData;//接收缓冲区。
    char *m_pSendData;//发送缓冲区。
    bool m_IsSendData;//由于只有接收到客户端请求后才需要发送，该变量控制是否发送数据。
};

CClient 类实现文件（Client.cpp）

#include "Client.h"  

CClient::CClient(void){}  

CClient::CClient(SOCKET s, sockaddr_in addr)  
{
    //初始化各成员变量。  
    m_socket=s;  
    m_addr=addr;  
    m_hRecvThread=NULL;  
    m_hSendThread=NULL;  
    m_IsConnected=true;  
    m_IsSendData=true;  
    m_hEvent=CreateEvent(NULL,true,false,NULL);  
    m_pRecvData=new char[1024];  
    m_pSendData=new char[1024];  
    memset(m_pSendData,0,1024);  
    memset(m_pRecvData,0,1024);  
}  

CClient::~CClient(void)  
{  
    delete []m_pRecvData;  
    delete []m_pSendData;  
}  

bool CClient::IsConnected()  
{  
    return m_IsConnected;  
}  

bool CClient::calc()  
{  
     time_t t;   
     struct tm *local;  
     char T[256];  
     memset(T,0,256);  
     t=time(NULL);  
     local=localtime(&t);  
     sprintf(T,"%d/%d/%d %d:%d:%d",local->tm_year+1900,local->tm_mon+1,local->tm_mday,local->tm_hour,local->tm_min,local->tm_sec);  
     strcpy(m_pSendData,T);  
    return true;  
}  

DWORD WINAPI CClient::sendThread(void* param)  //发送线程入口函数。  
{  
    std::cout<<"发送数据线程开始运行！！"<<std::endl;  
    CClient *pClient=static_cast<CClient*>(param);    //获得CClient对象指针。以便操纵成员变量。  
    WaitForSingleObject(pClient->m_hEvent,INFINITE);  //等待接收数据线程通知。
    while(pClient->m_IsConnected)  
    {  
        while(pClient->m_IsSendData)  //可以发送数据。  
        {  
            std::cout << "等待接收数据线程通知！！" << std::endl;  
            int ret = send(pClient->m_socket,pClient->m_pSendData,1024,0);  
            if(ret == SOCKET_ERROR)  
            {  
                int r = WSAGetLastError();  
                if(r == WSAEWOULDBLOCK)  
                {  
                    continue;  
                }  
                else  
                {  
                    return 0;  
                }  
            }  
            else  
            {  
                std::cout << "结果发送成功！！" << std::endl;  
                pClient->m_IsSendData = false;  
                break;  
            }
        }  
        Sleep(1000);//未收到发送通知，睡眠1秒。
    }  
}  

DWORD WINAPI CClient::recvThread(void* param)  //接收数据线程入口函数。
{  
    std::cout << "接收数据线程开始运行！！" << std::endl;  
    CClient *pClient = static_cast<CClient*>(param);  
    while(pClient->m_IsConnected)  
    {  
        memset(pClient->m_pRecvData, 0, 1024);  
        int ret = recv(pClient->m_socket, pClient->m_pRecvData, 1024, 0);  
        if(ret == SOCKET_ERROR)  
        {  
            int r = WSAGetLastError();  
            if(r == WSAEWOULDBLOCK)  
            {  
                Sleep(20);  
                continue;  
            }  
            else if(r == WSAENETDOWN)  
            {  
                std::cout << "接收数据线程出现错误,连接中断！" << std::endl;  
                break;  
            }  
            else  
            {  
                std::cout << "接收数据线程出现错误！" << std::endl;  
                break;  
            }  
        }  
        else  
        {  
            std::cout << "恭喜，收到来自客户端的数据:" << pClient->m_pRecvData << std::endl;  
            pClient->calc();  
            std::cout << "通知发送线程发送结果！！" << std::endl;  
            SetEvent(pClient->m_hEvent);  
            pClient->m_IsSendData = true;  
        }  
    }  
    return 0;  
}

bool CClient::startRunning()  //开始为连接创建发送和接收线程。  
{  
    //由于static成员函数，无法访问类成员。因此传入this指针。
    m_hRecvThread = CreateThread(NULL,0,recvThread,(void*)this,0,NULL);
    if(m_hRecvThread == NULL)  
    {  
        return false;  
    }  
    m_hSendThread = CreateThread(NULL,0,sendThread,(void*)this,0,NULL);  
    if(m_hSendThread == NULL)  
    {  
        return false;  
    }  
    return true;  
}  

bool CClient::DisConnect()  
{  
    m_IsConnected = false;  //接收和发送线程退出。资源释放交由资源释放线程。  
    return true;  
}

服务器主文件：

#include"windows.h"  
#include<iostream>  
#include<list>  
#include"Client.h"  
#pragma comment(lib,"wsock32.lib")  

HANDLE hAcceptHandle;  
HANDLE hCleanHandle;  
HANDLE hEvent;  
SOCKET servSocket;  
CRITICAL_SECTION cs;  
bool IsServerRunning;  
std::list<CClient*> clientlist;  //该链表中存储与服务器建立的各连接。清理线程将执行对此链表进行删除操作。  

bool InitMemember();   //初始化成员变量。  
bool InitSocket();     //初始化套接字，设置为非阻塞模式。绑定并监听。  
bool StartService();   //开始运行接收客户端请求线程
bool StopService();    //终止服务器运行。  
DWORD WINAPI CleanThread(void*param);   //资源清理线程。  
DWORD WINAPI AcceptThread(void*param);  //接受客户端请求线程。  

int main(int argc,char**argv)  
{  
    InitMemember();  
    InitSocket();

    do  
    {  
        char c;  
        std::cout<<"请选择操作："<<std::endl;  

        std::cin>>c;  
        if(c=='e')  
        {  
            std::cout<<"即将退出服务器程序。"<<std::endl;  
            StopService();  
        }  
        else if(c=='y')  
        {  
            if(IsServerRunning)  
            {  
                std::cout<<"服务器已经开启，请不要重复开启！！"<<std::endl;  
            }  
            else  
            {  
                StartService();  
            }  
        }  
        else if(c=='n')  
        {  
            if(!IsServerRunning)  
            {  
                std::cout<<"服务器未开启，无法关闭！！"<<std::endl;  
            }  
            else  
            {  
                StopService();  
            }  
        } 
        getchar();  
    }while(IsServerRunning);  

    Sleep(3000);  
    WaitForSingleObject(CleanThread,INFINITE);  

    return 0;  
}  

bool InitMemember()  
{  
    std::cout<<"初始化变量。"<<std::endl;  

    IsServerRunning=false;  
    hEvent=NULL;  
    hCleanHandle=NULL;  
    hAcceptHandle=NULL;  
    InitializeCriticalSection(&cs);  
    servSocket=INVALID_SOCKET;  
    return 0;  
}  

bool InitSocket()  
{  
    std::cout<<"初始化套接字。"<<std::endl;  

    WSADATA wsadata;  
    WSAStartup(MAKEWORD(2,2),&wsadata);  

    servSocket=socket(AF_INET,SOCK_STREAM,0);  
    if(servSocket==INVALID_SOCKET)  
    {  
        return false;  
    }  
    unsigned long ul=1;  
    int r=ioctlsocket(servSocket,FIONBIO,&ul);  
    if(r==SOCKET_ERROR)  
    {  
        return false;  
    }  
    sockaddr_in addr;  
    addr.sin_addr.S_un.S_addr=INADDR_ANY;  
    addr.sin_family=AF_INET;  
    addr.sin_port=htons(5000);  
    r=bind(servSocket,(sockaddr*)&addr,sizeof(addr));  
    if(r==SOCKET_ERROR)  
    {  
        return false;  
    }  
    int ret=listen(servSocket,10);  
    if(ret==SOCKET_ERROR)  
    {  
        return false;  
    }  
    return true;  
}  

bool StartService()  
{  
    std::cout<<"开启服务器。"<<std::endl;  

    IsServerRunning=true;  

    hAcceptHandle=CreateThread(NULL,0,AcceptThread,NULL,0,NULL);  
    if(hAcceptHandle==NULL)  
    {  
        return false;  
    }  
    CloseHandle(hCleanHandle);  
    CloseHandle(hAcceptHandle);  
}  

bool StopService()  
{  
    std::cout<<"关闭服务器。"<<std::endl;  
    hCleanHandle=CreateThread(NULL,0,CleanThread,NULL,0,NULL);  
    if(hCleanHandle==NULL)  
    {  
        std::cout<<"清理线程创建失败！"<<std::endl;  
        return false;  
    }  
    IsServerRunning=false;  
    return 0;  
}  

DWORD WINAPI CleanThread( void*param )  
{  
    std::cout<<"资源清理线程已运行"<<std::endl;  
     //中断所有连接。退出所有接收和发送线程循环。各线程将会退出。  
    for(std::list<CClient*>::iterator iter=clientlist.begin();iter!=clientlist.end();iter++)  
    {  
        (*iter)->DisConnect();  
    }  
    Sleep(100);  
    for(std::list<CClient*>::iterator iter=clientlist.begin();iter!=clientlist.end();iter++)  
    {  
        delete *iter;  
    }  
    clientlist.clear();  
    SetEvent(hEvent);  
    std::cout<<"资源清理完毕，资源清理线程退出！！"<<std::endl;  
    return 0;  
}  

DWORD WINAPI AcceptThread( void*param )  
{  
    std::cout<<"接受客户端连接线程开始运行。"<<std::endl;  

    while(IsServerRunning)  
    {  
        sockaddr_in addr;  
        SOCKET s;  
        int len=sizeof(addr);  
        s=accept(servSocket,(sockaddr*)&addr,&len);  
        if(s==SOCKET_ERROR)  
        {  
            int r=WSAGetLastError();  
            if(r==WSAEWOULDBLOCK)  
            {  
                Sleep(1000);  
                continue;  
            }  
            else  
            {  
                std::cout<<"未知错误，接受客户端连接线程退出。"<<std::endl;  
                getchar();  
                return false;  
            }  
        }  
        else//收到客户端请求。  
        {  
            std::cout<<"收到客户端的连接请求。"<<std::endl;  

            CClient*pClient=new CClient(s,addr);  
            pClient->startRunning();//该链接接受和发送线程开始执行。  
            clientlist.push_back(pClient);  
        }  
    }  
    std::cout<<"接受客户端连接线程退出。"<<std::endl;  

    return 0;  
}

客户端：

客户端程序：由主线程、接收数据线程和发送数据线程组成。

主线程：负责界面显示，初始化socket库、创建套接字，连接服务器、接收用户输入、创建发送和接收数据线程。

发送线程：向服务器发送数据。
接收线程：接收从服务器发送的时间日期。

客户端主文件：

#include<iostream>  
#include"windows.h"  
#pragma  comment (lib,"wsock32.lib")  

SOCKET clientSocket;  
HANDLE hRecvThread;  
HANDLE hSendThread;  
bool IsConnected;  
char sendBuff[1024];  
char recvBuff[1024];  
HANDLE hEvent;  
HANDLE hSendEvent;  

bool InitMember();  
bool InitSocket();  
bool startConnect();  
DWORD WINAPI recvThread(void*param);  
DWORD WINAPI sendThread(void*param);  

int main(int argc,char**argv)  
{  
    InitMember();  
    InitSocket();  
    startConnect();  
    char buff[256];  
    while(IsConnected)  
    {  
        memset(buff,0,256);  
        std::cout<<"请输入表达式：";  
        std::cin>>sendBuff;  
        if(!strcmp(buff,"exit"))  
        {  
            std::cout<<"即将推出！"<<std::endl;  
            IsConnected=false;  
            HANDLE hHandleArray[2];  
            hHandleArray[0]=hRecvThread;  
            hHandleArray[1]=hSendThread;  
            SetEvent(hEvent);  
            WaitForMultipleObjects(2,hHandleArray,true,INFINITE);  
            getchar();  
            return 0;  
        }  
        else  
        {  
            SetEvent(hEvent);  
        }  
    }  

    return 0;  
}  

//初始化套接字。  
bool InitSocket()  
{  
    WSAData wsadata;  
    WSAStartup(MAKEWORD(2,2),&wsadata);  
    clientSocket=socket(AF_INET,SOCK_STREAM,0);  
    if(clientSocket==INVALID_SOCKET)  
    {  
        return false;  
    }  
    unsigned long ul=1;  
    ioctlsocket(clientSocket,FIONBIO,&ul);  

    sockaddr_in addr;  
    addr.sin_family=AF_INET;  
    addr.sin_port=htons(5000);  
    addr.sin_addr.S_un.S_addr=inet_addr("192.168.1.100");  
    while(true)  
    {  
        int ret=connect(clientSocket,(sockaddr*)&addr,sizeof(addr));  
        if(ret==SOCKET_ERROR)  
        {  
            int r=WSAGetLastError();  
            if(r==WSAEWOULDBLOCK||r==WSAEINVAL)  
            {  
                Sleep(20);  
                continue;  
            }  
            else if(r==WSAEISCONN)//套接字原来已经连接！！  
            {  
                break;  
            }  
            else  
            {  
                std::cout<<"发生错误"<<std::endl;  
                return false;  
            }  
        }  
        if(ret==0)  
        {  
            break;  
        }  
    }  
    IsConnected=true;  
    return true;  
}  

bool InitMember()  
{  
    hSendThread=NULL;  
    hRecvThread=NULL;  
    hEvent=CreateEvent(NULL,true,false,NULL);  
    hSendEvent=CreateEvent(NULL,true,false,NULL);  
    IsConnected=false;  
    memset(recvBuff,0,1024);  
    memset(sendBuff,0,1024);  
    return true;  
}  

//创建接收和发送数据线程。  
bool startConnect()  
{  
    hRecvThread=CreateThread(NULL,0,recvThread,NULL,0,NULL);  
    if(hRecvThread==NULL)  
    {  
        return false;  
    }  
    hSendThread=CreateThread(NULL,0,sendThread,NULL,0,NULL);  
    if(hSendThread==NULL)  
    {  
        return false;  
    }  
    return 0;  
}  

//接收数据线程入口函数。  
DWORD WINAPI recvThread( void*param )  
{  
    std::cout<<"数据接收线程已开始运行！"<<std::endl;  
    while(IsConnected)  
    {  
        WaitForSingleObject(hSendEvent,INFINITE);  
        //ResetEvent(hSendEvent);  
        int ret=recv(clientSocket,recvBuff,1024,0);  
        if(ret==SOCKET_ERROR)  
        {  
            int r=WSAGetLastError();  
            if(r==WSAEWOULDBLOCK)  
            {  
                //std::cout<<"没有收到服务器返回的数据！！"<<std::endl;  
                Sleep(10);  
                continue;  
            }  
            else if(r==WSAENETDOWN)  
            {  
                std::cout<<"数据发送失败！"<<std::endl;  
                return false;  
            }  
        }  
        else  
        {  
            std::cout<<"接收成功！"<<std::endl;  

            std::cout<<recvBuff<<std::endl;  
        }  
    }  
    return true;  
}  

//发送数据线程入口函数。  
DWORD WINAPI sendThread( void*param )  
{  
    std::cout<<"数据发送线程已开始运行！！"<<std::endl;  

    while(IsConnected)//是否与服务器连接  
    {  
        WaitForSingleObject(hEvent,INFINITE);//等待接收数据线程通知。  
        ResetEvent(hEvent);  
        int ret=send(clientSocket,sendBuff,256,0);  
        if(ret==SOCKET_ERROR)  
        {  
            int r=WSAGetLastError();  
            if(r==WSAEWOULDBLOCK)  
            {  
                std::cout<<"数据发送失败！"<<std::endl;  
                Sleep(20);  
                continue;  
            }  
            else  
            {  
                std::cout<<"数据发送失败！"<<std::endl;  
                break;  
            }  
        }  
        else  
        {  
            std::cout<<"发送成功！！"<<std::endl;  
            SetEvent(hSendEvent);  
        }  
    }  
    return true;  
}

这里写图片描述

本文内容及代码参考自《Windows Sockets 网络开发–基于Visual C++实现》孙海民编。如有错误，请不吝指正！
2012、12、9

Windows平台下非阻塞Socket模型总结
Fly Follow the Heart
06-06 2496
Windows平台的5种非阻塞Socket编程模型： Select模型(集合管理多个Socket，集合中有64个元素，可以管理1024个socket)         Socket通信库所提供的一种异步接收与发送的机制，它是独立于平台的，无论是Linux还是Windows都可以使用。         使用了一个FD_SET变量，将想要“监听”的Socket加入该集合中，调用Selec
Windows Socket 异步编程（非阻塞模式）
weixin_30902675的博客
03-31 523
1. Windows平台提供了5种非阻塞Socket编程模型： Select模型(集合管理多个Socket，集合中有64个元素，可以管理1024个socket) WSAAsyncSelect模型(消息通知应用程序) WSAEventSelect模型(事件通知应用程序) 每次只能等待64个事件 重叠I/O模型(Overlapped I/O,事件通知和完成例程来通知应用程序) 事件通知即通...
一个WinSocket的编程实例
王浩烽的专栏
03-31 843
Server： #include #include #include #define DEFAULT_PORT 5050 //服务端默认端口 int main() { int iPort = DEFAULT_PORT; WSADATA wsaData; SOCKET sListen,sAccept; int
Windows Socket 异步编程(非阻塞)
zh653的博客
10-13 1938
使用Select异步模式来实现返送示例。服务器启动并监听9999端口，并将收到的客户端信息打印并返送给客户端。 重点理解的是：一个套接字是否是可读、可写状态。当服务器端socket在Accept成功之后，便是可读状态，接收客户端发送数据。当客户端发送recv函数时，这个socket便成为可写状态，服务器端便知道这个客户端可写，然后根据自己的定义发送给客户端内容。如果客户端不发送recv函数，即下面Client中的recv函数的话，服务器端保存的客户端这个socket便没有进入可写状态的时候，也就不会有回送的
windows的阻塞和非阻塞Socket编程
03-19
在Windows中，可以使用WSAAsyncSelect()或WSAEventSelect()函数将Socket设置为非阻塞模式，并与Windows消息机制相结合，实现异步事件通知。这两种方法允许程序在等待Socket事件的同时处理其他任务，提高了系统的并发...
vb6 纯API实现阻塞和非阻塞模式Socket
03-12
VB6纯API实现阻塞和非阻塞模式Socket涉及到了对Windows API的深入理解和使用，需要开发者具备一定的网络编程基础和对Windows编程模型的理解。虽然VB6是一个较老的开发环境，但通过纯API实现Socket编程依然是一个值得...
Socket C++ TCP阻塞\非阻塞 服务器 客户端 开发
05-20
通过本文档的学习，您不仅了解了如何使用C++ Winsock来开发TCP非阻塞服务器，还学习了如何设置socket为非阻塞模式以及如何设计SOCKET类来更好地管理socket操作。此外，还提供了一个简单的服务器示例代码，帮助理解...
feizuse.rar_C socket 非阻塞_网络服务_非阻塞_非阻塞 socket
09-19
4. 设置非阻塞模式：在Windows下，可以通过`ioctlsocket()`函数配合`FIONBIO`标志来设置`socket`为非阻塞模式。 5. 异步事件处理：`WSAAsyncSelect()`或`WSAEventSelect()`函数的使用，以及如何根据接收到的事件进行...
socket 多线程 例程 非阻塞模式
05-13
在这个"socket多线程例程非阻塞模式"的示例中，我们将深入探讨如何在Windows平台上实现多线程的socket通信，并了解非阻塞模式的工作原理。 首先，让我们来理解Socket的基本概念。Socket是进程间通信（IPC）的一种...
Windows sockets 网络编程(三)— 非阻塞模式开发
holylts的专栏
10-05 1083
<br />一、套接字的非阻塞模式<br />       套接字的非阻塞模式是指套接字在执行操作时，调用的函数不管操作是否完成都会立即返回的工作模式。根据其返回的错误代码，确定操作是否正确完成。<br />二、设置套接字的非阻塞模式<br />       在使用socket()和WSASocket()函数创建套接字时，默认都是阻塞模式的。在创建套接字之后，可以通过调用ioctlsocket()函数，将套接字设置为非阻塞模式。<br />       int ioctlsocket(SOCKETs, lo
windows环境下设置socket为非阻塞模式
xkdlzy的专栏
05-13 814
socket 阻塞模式
Winsocket入门教程二：非阻塞式服务器和客户端程序(TCP)
shining100的专栏
06-06 4770
上次为大家介绍了阻塞式多线程服务端程序和阻塞式客户端程序的设计方法，但是在上文的最后也提到过，服务器程序会因为建立连接和关闭连接而频繁的创建和关闭线程会产生大量的内存碎片，从而导致服务端程序不能保证长时间的稳定运行。因此我在这里为大家介绍另外一种建立服务器和客户端程序的方法，即建立非阻塞式的服务器和客户端程序。那什么是非阻塞呢？非阻塞是相对于阻塞而言，阻塞指的是在进行一个操作的时候，如服务器接收客户端的连接(accept)，服务器或者客户端读写数据(read、write)，如果该操作没有执行完成(成功或者失
winsocket c++ 非阻塞方式
myt0929的专栏
08-29 1836
#include #include #include #pragma comment(lib,"ws2_32.lib") int main() { //加载socket动态库 WORD wVersionRequested; WSADATA wsaData; wVersionRequested = MAKEWORD(2,2); auto err = WSAStart
Windows网络编程（八）：非阻塞模式（异步模式）
tutucoo
11-26 690
前面几篇文章介绍的无论是TCP通信还是UDP通信都是阻塞式的，它们在执行recv或recvfrom时会在线程中等待，直到接收到信息为止，所以在应用的时候一般都需要开辟子线程，在子线程里专门做这类事情，不然它会影响主线程的运行。&amp;nbsp; 系统提供三种网络模型去处理这类需求，它们都基于异步模式，在异步模式下执行recv或recvfrom时不会在线程中等待，它会接着执行下去，当接收到消息时，系...
java socket 阻塞模式_（四） 如何将socket设置为非阻塞模式
weixin_39633090的博客
02-12 1056
1. windows平台上无论利用socket()函数还是WSASocket()函数创建的socket都是阻塞模式的：SOCKET WSAAPI socket( _In_ int af, _In_ int type, _In_ int protocol ); SOCKET WSASocket( _In_ int af, ...
C/C++网络编程在windows将socket设置为非阻塞
qq_41854911的博客
04-01 2565
在 socket编程中，对于socket的读写默认都是阻塞的，但有的情况我们需要将其设置为非阻塞，比如做多路复用，或者通过select实现连接超时等功能，将socket设置为非阻塞，在windows和linux中的接口有所不同，在windows中使用ioctlsocket函数，在linux中使用 fcntl函数，下面我们做一个跨平台设置阻塞的函数SetBlock。
socket 非阻塞模式
最新发布
03-26
<think>嗯，用户问的是socket的非阻塞模式，我得先理清楚这个概念。首先，socket是网络编程的基础，非阻塞模式应该和I/O模型有关。那阻塞和非阻塞的区别是什么来着？阻塞模式下，当程序执行一个网络操作，比如recv()，如果没有数据可读，线程就会一直卡在那里，直到有数据到达。而非阻塞模式的话，调用会立即返回，不管有没有数据，这样程序可以继续做其他事情，不需要等待。 接下来需要解释非阻塞模式的特点。比如，当设置为非阻塞后，调用accept、connect、recv、send这些函数时，如果没有立即完成，会返回一个错误码，比如EAGAIN或者EWOULDBLOCK。这时候程序应该处理这个错误，而不是一直阻塞。这能提高程序的响应能力，特别是在需要同时处理多个连接的时候。 然后，用户可能想知道如何设置socket为非阻塞模式。不同的系统有不同的方法，比如在Linux下可以用fcntl设置O_NONBLOCK标志，而Windows下则是ioctlsocket函数。这部分需要具体说明，最好给出代码示例，比如用fcntl的步骤：获取当前标志，加上非阻塞标志，再设置回去。 还要讨论非阻塞模式的应用场景。比如高并发服务器，比如游戏服务器或者实时通信系统，这些需要同时处理大量连接的地方，用非阻塞模式结合I/O多路复用（如select、epoll）会更高效。不过也要提到缺点，比如编程复杂度增加，需要循环检查状态，处理错误，可能消耗更多CPU资源。 用户可能还关心与非阻塞模式相关的其他技术，比如异步I/O、多路复用机制（select、poll、epoll）。需要比较这些技术的异同，说明非阻塞模式通常是这些机制的基础。 然后要总结非阻塞模式的优缺点。优点包括提高并发性、资源利用率，避免线程阻塞；缺点是代码复杂，调试困难，可能忙等消耗CPU。 最后，给出一个简单的代码示例，展示如何设置socket为非阻塞，并进行错误处理。比如用fcntl设置，然后尝试accept，如果返回EAGAIN就等待或者处理其他任务。 需要确保回答结构清晰，分点说明，使用中文，同时注意数学公式的正确LaTeX格式，但这个问题可能不涉及数学公式，所以可能不需要用。不过如果有提到什么算法或公式，要用对应的格式。但socket非阻塞模式更多是概念和代码，所以重点在代码示例和步骤说明。 检查是否遗漏了重要点，比如非阻塞模式下的connect如何处理，可能返回EINPROGRESS，需要用select等检查连接是否完成。这也是一个关键点，需要补充到流程中。 另外，要注意用户可能混淆非阻塞和异步的概念，需要区分两者。异步I/O可能在操作完成后通过回调通知，而非阻塞则需要主动轮询，所以两者的机制不同。 最后确保语言通俗，避免过于技术化的术语，但也要准确。可能需要分步骤解释，比如如何设置，如何处理返回的错误，如何结合多路复用等。</think>Socket 非阻塞模式是网络编程中一种重要的 I/O 模型，其核心目标是避免线程因等待 I/O 操作而阻塞。以下是逐步解析： --- ### **1. 阻塞与非阻塞的本质区别** - **阻塞模式**：当调用 `recv()`, `accept()`, `connect()` 等函数时，若操作无法立即完成（如无数据可读、无新连接到达），线程会**暂停执行**，直到条件满足。 - **非阻塞模式**：无论操作是否完成，函数都会**立即返回**。若操作未完成，会返回错误码（如 `EWOULDBLOCK` 或 `EAGAIN`），线程可继续执行其他任务。 --- ### **2. 如何设置非阻塞模式** #### **Linux/Unix 系统** ```c #include <fcntl.h> int flags = fcntl(sockfd, F_GETFL, 0); // 获取当前标志 fcntl(sockfd, F_SETFL, flags | O_NONBLOCK); // 添加非阻塞标志 ``` #### **Windows 系统** ```c #include <winsock2.h> u_long mode = 1; // 1 表示非阻塞，0 表示阻塞 ioctlsocket(sockfd, FIONBIO, &mode); ``` --- ### **3. 非阻塞操作的行为** - **读操作**（`recv`）：若无数据可读，立即返回错误码。 - **写操作**（`send`）：若内核缓冲区已满，立即返回错误码。 - **连接操作**（`connect`）：若无法立即完成，返回 `EINPROGRESS`，需后续通过 `select` 或 `getsockopt` 检查连接状态。 --- ### **4. 错误码处理示例** ```c ssize_t n = recv(sockfd, buffer, sizeof(buffer), 0); if (n == -1) { if (errno == EAGAIN || errno == EWOULDBLOCK) { // 无数据可读，稍后重试 } else { // 真实错误（如连接断开） } } ``` --- ### **5. 与非阻塞模式配合的技术** - **I/O 多路复用**：通过 `select`、`poll`、`epoll`（Linux）或 `kqueue`（BSD）**监控多个 socket 状态**，避免忙等。 - **事件循环**：在单线程中高效处理多个连接的读写事件，典型应用于 Nginx、Redis 等高性能服务。 --- ### **6. 典型应用场景** 1. **高并发服务器**：单线程同时处理成千上万个连接。 2. **实时系统**：如游戏服务器需快速响应多个客户端。 3. **异步任务**：避免 I/O 操作阻塞主逻辑线程。 --- ### **7. 优缺点对比** | **优点** | **缺点** | |-----------------------------------|-----------------------------------| | 提高 CPU 利用率 | 需处理复杂的状态检查和错误码 | | 避免线程上下文切换开销 | 代码复杂度显著增加 | | 单线程即可实现高并发 | 需配合多路复用机制避免忙等 | --- ### **8. 与非阻塞相关的关键问题** - **数据边界处理**：非阻塞模式下，`send` 和 `recv` 可能无法一次性完成，需实现**缓冲区管理**。 - **连接超时控制**：非阻塞 `connect` 需手动设置超时检测逻辑。 - **公平调度**：需避免某个 socket 长期占用 CPU（如通过轮询权重机制）。 --- ### **9. 代码片段：非阻塞 accept 示例** ```c int sockfd = socket(AF_INET, SOCK_STREAM, 0); // 设置非阻塞 fcntl(sockfd, F_SETFL, O_NONBLOCK); while (1) { int client_fd = accept(sockfd, NULL, NULL); if (client_fd == -1) { if (errno == EAGAIN) { // 无新连接，处理其他任务 usleep(1000); // 避免忙等 } else { perror("accept error"); break; } } else { // 处理新连接 } } ``` --- ### **总结** 非阻塞模式通过**立即返回 + 错误码反馈**的机制，使程序能够高效管理多个 I/O 操作，但其代价是代码复杂度的显著上升。实际开发中通常结合**多路复用**和**事件驱动架构**，在资源利用率和开发效率间取得平衡。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值