计算机网络 完成端口模型

最新推荐文章于 2022-12-30 23:20:46 发布
最新推荐文章于 2022-12-30 23:20:46 发布
阅读量199 收藏
点赞数
文章标签： 服务器 windows 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/van9527/article/details/126541150
版权

首先 大致了解一下完成端口的结构和原理

 1.首先 完成端口的特性:

异步 非阻塞  效率较高

2.原理:

预先创建好n个空闲的Waiter套接字 

然后把这些套接字交给监听套接字管理 

再将监听套接字交给IOCP完成端口处理  

创建好我们的线程池

 如果有n客户端链接我们的服务器

 我们就新创建出n个空闲的线程  来维持空闲的线程数量平衡

然后向内核投递接受数据请求

将相应的Waiter交给IOCP管理

完整代码如下

类声明

#ifndef CTCPMAP_H
#define CTCPMAP_H

#include<list>
#include<winsock2.h>
#include<windows.h>
#include<iostream>
#include <Mswsock.h>
#include<map>
using namespace std;
#define MaxNum 64
#define NT_ACCEPT 0
#define NT_READ 1
struct DataInfo
{
    char* pszbuf;
    int  nPacksize;
    int  noffest;
};

struct MySocket
{
    OVERLAPPED olp;//用来发通知
    SOCKET socket;//套接字waiter
    char szbufp[1024];//接收缓冲区
    int  type;//判断网络类型
};

class CTCPmap
{
public:
    //构造
    CTCPmap();
    //析构
    ~CTCPmap();
    //初始化网络
    bool InitnewWork();
    //销毁网络
    void DeleteWork();
    //线程函数
    static DWORD WINAPI ThreadEventSelect(LPVOID lpvoid);
    static DWORD WINAPI ThreadIOCP(LPVOID lpvoid);
    static DWORD WINAPI ThreadSelect(LPVOID lpvoid);
    static DWORD WINAPI ThreadAccept(LPVOID lpvoid);
    static DWORD WINAPI ThreadRecv(LPVOID lpvoid);
    //发送数据
    bool sendDate(SOCKET sockWaiter,char*szbuf,int nLen);
    //接收数据
    void recvDate();
    bool PostAccept();
    bool PostRecv(MySocket*);


private:
    //监听者句柄
    SOCKET m_soclisten;
    //总线程池
    std::list<HANDLE> my_Threadpool;
    //服务者线程池
    std::list<SOCKET> my_ThreadWaiter;
    //我的套接字链表
    std::list<MySocket*> my_mysocketWaiter;
    //线程结束标识
    bool my_FlagQuit;
    //传服务者sockWaiter用到的容器
    std::map<DWORD,SOCKET> my_map;
    //结构体与套接字的映射
    std::map<SOCKET,DataInfo*> m_sdmap;
    fd_set m_fd;
    SOCKET m_arySocket[MaxNum];
    HANDLE m_aryEvent[MaxNum];
    int  m_nEventNum;
    HANDLE m_hIOCP;



};

#endif // CTCPMAP_H

类定义

#include "ctcpmap.h"

CTCPmap::CTCPmap()
{

    m_soclisten=0;
    my_FlagQuit=true;
    FD_ZERO(&m_fd);
    m_nEventNum=0;
    ZeroMemory(m_arySocket,sizeof(m_arySocket));
    ZeroMemory(m_aryEvent,sizeof(m_aryEvent));
    m_hIOCP=0;

}
CTCPmap::~CTCPmap()
{

}

bool CTCPmap::InitnewWork()
{

    WORD wVersionRequested;
    WSADATA wsaData;
    int err;


    wVersionRequested = MAKEWORD(2, 2);

    err = WSAStartup(wVersionRequested, &wsaData);
    if (err != 0) {


        DeleteWork();
        return false;
    }



    if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {

        WSACleanup();
        return false;
    }




//创建套接字
    m_soclisten=socket(AF_INET,SOCK_STREAM,0);
    if(m_soclisten==INVALID_SOCKET)
    {
       DeleteWork();
        return false;
    }
//绑定
    sockaddr_in addrserver;
    //绑定IP
    addrserver.sin_addr.S_un.S_addr=0;
    addrserver.sin_port=htons(8899);
    addrserver.sin_family=AF_INET;
    if(SOCKET_ERROR==bind(m_soclisten,(sockaddr*)&addrserver,sizeof(addrserver)))
    {
          DeleteWork();
            return false;

    }



//监听

    if(SOCKET_ERROR==listen(m_soclisten,10))

    {
        DeleteWork();
        return false;

    }
    //1.创建IOCP
    m_hIOCP=CreateIoCompletionPort(INVALID_HANDLE_VALUE,NULL,NULL,NULL);
    //2.将listen 交给IOCP
    CreateIoCompletionPort((HANDLE)m_soclisten,m_hIOCP,m_soclisten,0);
    //3.创建空闲Waiter
    SYSTEM_INFO si;
    GetSystemInfo(&si);
    for(int i=0;i <si.dwNumberOfProcessors;i++)
    {
        if(!PostAccept())i--;
    }


    //4.创建线程池
    for(int i=0;i <si.dwNumberOfProcessors;i++)
    {
        HANDLE hand=CreateThread(0,0,&ThreadIOCP,this,0,0);
         if(hand)
            my_Threadpool.push_back(hand);
    }

//    HANDLE hevent=WSACreateEvent();

//    if(!WSAEventSelect(m_soclisten,hevent,FD_ACCEPT))
//    {
//        m_arySocket[m_nEventNum]=m_soclisten;
//        m_aryEvent[m_nEventNum]=hevent;
//        m_nEventNum++;
//    }

//    HANDLE hand=CreateThread(0,0,&ThreadEventSelect,this,0,0);
//    if(hand)
//       my_Threadpool.push_back(hand);

//    //将套接字加入到集合
//    FD_SET(m_soclisten,&m_fd);
//    //创建线程
//    HANDLE hand=CreateThread(0,0,&ThreadSelect,this,0,0);
//    if(hand)
//       my_Threadpool.push_back(hand);
//    HANDLE hand=CreateThread(0,0,&ThreadAccept,this,0,0);
//    if(hand)
//        my_Threadpool.push_back(hand);
//    hand=CreateThread(0,0,&ThreadRecv,this,0,0);
//    //创建服务者线程 加入到线程池
//    if(hand)
//        my_Threadpool.push_back(hand);

    return  true;


}

void CTCPmap::DeleteWork()
{
    //线程销毁
    my_FlagQuit=false;
    auto ite=my_Threadpool.begin();
    while(ite!=my_Threadpool.end())
    {
        if(WAIT_TIMEOUT==WaitForSingleObject(*ite,100))
            TerminateThread(*ite,-1);
        CloseHandle(*ite);
        *ite=NULL;
        ite++;
    }

    my_Threadpool.clear();
     //关闭句柄
    if(m_soclisten)
        {
        closesocket(m_soclisten);
        m_soclisten=0;
    }

    //卸载服务器
    WSACleanup();
}

DWORD WINAPI CTCPmap::ThreadEventSelect(LPVOID lpvoid)
{
    CTCPmap *pthis=(CTCPmap*)lpvoid;
    DWORD dwIndex;
    WSANETWORKEVENTS we;
    sockaddr_in addrclient;
    int  nsize=sizeof(addrclient);
    int  nRecvNum;
    while(pthis->my_FlagQuit)
    {
        //等事件
        dwIndex=WSAWaitForMultipleEvents(pthis->m_nEventNum,pthis->m_aryEvent,FALSE,WSA_INFINITE,0);
        dwIndex-=WSA_WAIT_EVENT_0;
        //判断发生什么事
        if(SOCKET_ERROR==WSAEnumNetworkEvents(pthis->m_arySocket[dwIndex],
                                               pthis->m_aryEvent[dwIndex],
                                               &we))
            continue;
        //处理
        if(we.lNetworkEvents&FD_ACCEPT)
        {
            cout<<"等待客户端连接"<<endl;
            SOCKET sockWaiter=accept(pthis->m_soclisten,(sockaddr*)&addrclient,&nsize);

            cout<<"client ip:"<<inet_ntoa(addrclient.sin_addr)<<"accept"<<endl;

            //对应失败  跳出 继续循环
            if(sockWaiter==INVALID_SOCKET)continue;
            HANDLE hevent=WSACreateEvent();//人工的无信号事件

            if(!WSAEventSelect(sockWaiter,hevent,FD_READ|FD_CLOSE))
            {
                pthis->m_arySocket[pthis->m_nEventNum]=sockWaiter;
                pthis->m_aryEvent[pthis->m_nEventNum]=hevent;
                pthis->m_nEventNum++;
            }


        }

        if(we.lNetworkEvents&FD_READ)
            {
                DataInfo *pData=pthis->m_sdmap[pthis->m_arySocket[dwIndex]];
                //代表waiter 有数据来了
                if(!pData)
                {
                    pData=new DataInfo;
                    pData->noffest=0;
                    pData->nPacksize=0;
                    pthis->m_sdmap[pthis->m_arySocket[dwIndex]]=pData;
                    //waiter come
                    nRecvNum=recv(pthis->m_arySocket[dwIndex],(char*)&pData->nPacksize,sizeof(int),0);
                    if(pData->nPacksize>0)
                    {
                        pData->pszbuf=new char[pData->nPacksize];
                    }
                }
                else
                {
                    nRecvNum=recv(pthis->m_arySocket[dwIndex],pData->pszbuf+pData->noffest,pData->nPacksize,0);
                    if(nRecvNum>0)

                    {
                        pData->noffest+=nRecvNum;
                        pData->nPacksize-=nRecvNum;
                        if(pData->nPacksize==0)
                        {
                            //数据包接受完整
                            cout<<pData->pszbuf<<endl;
                            delete []pData->pszbuf;
                            pData->pszbuf=NULL;

                            delete [] pData;
                            pData=NULL;
                            pthis->m_sdmap[pthis->m_arySocket[dwIndex]]=NULL;

                        }
                    }
             }

             }

        if(we.lNetworkEvents&FD_CLOSE)
            {
                closesocket(pthis->m_arySocket[dwIndex]);
                WSACloseEvent(pthis->m_aryEvent[dwIndex]);
                if(pthis->m_nEventNum>1)
                {
                    pthis->m_arySocket[dwIndex]=pthis->m_arySocket[pthis->m_nEventNum-1];
                    pthis->m_aryEvent[dwIndex]=pthis->m_aryEvent[pthis->m_nEventNum-1];



                }
                pthis->m_nEventNum--;
            }



    }
    return  0;
}

DWORD CTCPmap::ThreadIOCP(LPVOID lpvoid)
{
    CTCPmap *pthis=(CTCPmap*)lpvoid;
    DWORD dwNumberOfByTesTransferred;
    SOCKET sock;
    MySocket *pSocket;
    BOOL bflag;
    while(pthis->my_FlagQuit)
    {
        bflag=GetQueuedCompletionStatus(pthis->m_hIOCP,
                                        &dwNumberOfByTesTransferred,
                                        (PULONG_PTR)&sock,
                                        (LPOVERLAPPED*)&pSocket,
                                        INFINITE);
        if(!bflag)
        {
            continue;
        }
        if(!sock&&!pSocket)
            continue;
        switch(pSocket->type)
        {
            case NT_ACCEPT:
            pthis->PostAccept();
            pthis->PostRecv(pSocket);
            CreateIoCompletionPort((HANDLE)pSocket->socket,pthis->m_hIOCP,pSocket->socket,0);
            break;
            case NT_READ:
            cout<<pSocket->szbufp<<endl;
            pthis->PostRecv(pSocket);
            break;
        }

    }
}
//将集合交给select线程函数
DWORD WINAPI CTCPmap::ThreadSelect(LPVOID lpvoid)
{
    CTCPmap *pthis=(CTCPmap*)lpvoid;
    fd_set fdtemp;
    TIMEVAL tv;
    tv.tv_sec=0;
    tv.tv_usec=100;
    sockaddr_in addrclient;

    int  nRecvNum;
    int  nsize=sizeof(addrclient);
    while(pthis->my_FlagQuit)
        {

        fdtemp =pthis->m_fd;
        //将套接字交给集合
         select(0,&fdtemp,0,0,&tv);
        if(FD_ISSET(pthis->m_soclisten,&fdtemp))
        {
            //代表有人连接我了
            SOCKET sockWaiter=accept(pthis->m_soclisten,(sockaddr*)&addrclient,&nsize);

            cout<<"client ip:"<<inet_ntoa(addrclient.sin_addr)<<"accept"<<endl;

            //对应失败  跳出 继续循环
            if(sockWaiter==INVALID_SOCKET)continue;
            //将waiter加入到集合内
            FD_SET(sockWaiter,&pthis->m_fd);
        }

        //校验
        for(unsigned int i=1;i<pthis->m_fd.fd_count;i++)
        {


            if(FD_ISSET(pthis->m_fd.fd_array[i],&fdtemp))
            {
                DataInfo *pData=pthis->m_sdmap[pthis->m_fd.fd_array[i]];
                //代表waiter 有数据来了
                if(!pData)
                {
                    pData=new DataInfo;
                    pData->noffest=0;
                    pData->nPacksize=0;
                    pthis->m_sdmap[pthis->m_fd.fd_array[i]]=pData;
                    //waiter come
                    nRecvNum=recv(pthis->m_fd.fd_array[i],(char*)&pData->nPacksize,sizeof(int),0);
                    if(pData->nPacksize>0)
                    {
                        pData->pszbuf=new char[pData->nPacksize];
                    }
                }
                else
                {
                    nRecvNum=recv(pthis->m_fd.fd_array[i],pData->pszbuf+pData->noffest,pData->nPacksize,0);
                    if(nRecvNum>0)

                    {
                        pData->noffest+=nRecvNum;
                        pData->nPacksize-=nRecvNum;
                        if(pData->nPacksize==0)
                        {
                            //数据包接受完整
                            cout<<pData->pszbuf<<endl;
                            delete []pData->pszbuf;
                            pData->pszbuf=NULL;

                            delete [] pData;
                            pData=NULL;
                            pthis->m_sdmap[pthis->m_fd.fd_array[i]]=NULL;

                        }
                    }
                }


            }

        }

}

     return  0;

}

//接收客户端的线程函数
 DWORD WINAPI CTCPmap::ThreadAccept(LPVOID lpvoid)
 {
     CTCPmap *pthis=(CTCPmap*)lpvoid;

     sockaddr_in addrclient;
     int  nsize=sizeof(addrclient);

     u_long iMode=1;
     while(pthis->my_FlagQuit)
     {
         //店长接受客人 分配给服务员  --接受链接--accept();

         //服务者与他的客人对应起来
             SOCKET sockWaiter=accept(pthis->m_soclisten,(sockaddr*)&addrclient,&nsize);

             cout<<"client ip:"<<inet_ntoa(addrclient.sin_addr)<<"accept"<<endl;

             //对应失败  跳出 继续循环
             if(sockWaiter==INVALID_SOCKET)continue;
             //对应成功 线程池添加了一个服务者线程

             //将Waiter 介入到链表 将waiter设置为非阻塞

             ioctlsocket(sockWaiter,FIONBIO,&iMode);

             //将服务者套接字加入到集合
             //FD_SET(sockWaiter,&(pthis->m_fd));

             pthis->my_ThreadWaiter.push_back(sockWaiter);






     }
     return  0;


 }

DWORD WINAPI CTCPmap::ThreadRecv(LPVOID lpvoid)
{
    CTCPmap *pthis=(CTCPmap*)lpvoid;

    while(pthis->my_FlagQuit)
    {
        // 接受
        pthis->recvDate();
        Sleep(10);

    }
    return  0;

}

void CTCPmap::recvDate()//接收函数
{

            // 服务员等客人说话 --recv();
                char *pszbuf=NULL;
                //当前位置标识
                int offset=0;
                //包长度
                int  nPackSize;

                int  nRecvNum;
                SOCKET sockWaiter;



                auto ite=my_ThreadWaiter.begin();
                while(ite!=my_ThreadWaiter.end())
                {
                    sockWaiter=*ite;

                        //jieshoubaodaxiao
                        nRecvNum=recv(sockWaiter,(char*)&nPackSize,sizeof(int ),0);
                        if(nRecvNum<=0)
                        {
                            //判断服务器是否下线
                            if(WSAGetLastError()==10054)
                            {
                                //删除映射
                                auto ite=my_map.begin();
                                while(ite!=my_map.end())
                                {
                                    if(ite->second==sockWaiter)
                                    {
                                        my_map.erase(ite);
                                        closesocket(sockWaiter);
                                        break;
                                    }
                                    //ite++;
                                }

                                break;
                            }
                            continue;
                            ite++;
                        }
                        //获得接受内容
                        pszbuf=new char[nPackSize];
                        while(nPackSize)//看当前剩余的还有多少没接受完
                        {
                            nRecvNum=recv(sockWaiter,pszbuf+offset,nPackSize,0);
                            if(nRecvNum>0)
                            {
                                nPackSize-=nRecvNum;
                                offset+=nRecvNum;
                            }
                        }
                        cout<<"client say:"<<pszbuf<<endl;
                        sendDate(sockWaiter,pszbuf,  nRecvNum);
                        delete []pszbuf;
                        pszbuf=NULL;





                     ite++;
                }




}

bool CTCPmap::PostAccept()
{

    MySocket* pSocket=new MySocket;
    pSocket->olp.hEvent=WSACreateEvent();
    pSocket->type=NT_ACCEPT;
    pSocket->socket=socket(AF_INET,SOCK_STREAM,0);
    if(!AcceptEx(m_soclisten,pSocket->socket,pSocket->szbufp,0,sizeof(sockaddr)+16,sizeof(sockaddr)+16,0,&pSocket->olp))
    {
        if(WSAGetLastError()!=ERROR_IO_PENDING)
        {
            WSACloseEvent(pSocket->olp.hEvent);
            closesocket(pSocket->socket);
            delete pSocket;
            pSocket=NULL;
            return  false;
        }
    }
    my_mysocketWaiter.push_back(pSocket);
    return true;
}

bool CTCPmap::PostRecv(MySocket *psocket)
{
    DWORD dwNumberOfBytesRecvd;
    DWORD dwFlag=0;
    psocket->type=NT_READ;
    WSABUF wb;
    wb.buf=psocket->szbufp;
    wb.len=sizeof(psocket->szbufp);
    if(WSARecv(psocket->socket,&wb,1,&dwNumberOfBytesRecvd,&dwFlag,&psocket->olp,0))

    {
        if(WSAGetLastError()!=WSA_IO_PENDING)
            return false;
    }


    return  true;

}


bool CTCPmap:: sendDate(SOCKET sockWaiter,char*szbuf,int  nLen)
{


    if(sockWaiter==INVALID_SOCKET||!szbuf||nLen<=0)
        return  false;
    if(send(sockWaiter,(char*)&nLen,sizeof(int ),0)<=0)
     return  false;
    if(send(sockWaiter,szbuf,nLen,0)<=0)
     return  false;

    int  nRecvNum;
    int nRecvNuumSIze=sizeof(szbuf);

    while(my_FlagQuit)
    {
        cin>>szbuf;

        send(sockWaiter,(char*)&nRecvNuumSIze,sizeof(int),0);
        send(sockWaiter,szbuf,sizeof(szbuf),0);

        //recv()
        nRecvNum= recv(sockWaiter,szbuf,sizeof(szbuf),0);
        if(sockWaiter>0)
        {
            cout<<"fuwuqi say:"<<szbuf<<endl;
        }



    }

   return true;

}

主函数

#include <QCoreApplication>
#include<winsock2.h>
#include<iostream>
#include"ctcpmap.h"
using namespace std;
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    /*
     *1.选择种类  --WSAStartup();
     *2.雇店长  --创建套接字 socket();
     *3.找地 --绑定 --bind();
     *4.店长宣传 --监听 --listen();
     *5.店长接受客人 分配给服务员  --接受链接--accept();
     *6.客人与服务员 服务员等客人说话 --recv();
     *7.回复 --send();
     *8.下班--closesocket();
     *9.关门--WASCleanup();
     *
     */

    CTCPmap ctcp;
    if(ctcp.InitnewWork())
        cout<<"initnework sucess"<<endl;







    return a.exec();
}

van9527
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
计算机网络基础教程.zip
06-22
1. 计算机网络概述 了解计算机网络的发展历史 了解计算机网络发展的新技术 熟悉计算机网络的分类和应用 掌握计算机网络的定义和功能 掌握计算机网络的组成与拓扑结构 2. 数据通信基础 了解数据通信系统中的基本概念...
c++ 完成端口
12-16
标题中的“C++ 完成端口”是指在Windows操作系统中使用I/O完成端口（I/O Completion Ports, IOCP）技术进行高效网络编程的一种方式。完成端口是Windows系统提供的一种多线程I/O模型，它能有效地处理大量并发连接，并...
windows socket网络编程之iocp完成端口模型的例子
04-17
windows socket网络编程之iocp完成端口模型的例子
Socket编程模型之完成端口模型
cheqiane9431的博客
08-14 414
转载请注明来源：http://blog.csdn.net/caoshiying?viewmode=contents 一、回顾重叠IO模型 用完成例程来实现重叠I/O比用事件通知简单得多。在这个模型中，主线程只用不停的接受连接即可；辅助线程判断有没有新的客户端连接被建立，如果有，...
网络编程 完成端口模型
weixin_62859191的博客
12-30 1117
网络编程 完成端口模型
C++ Windows Socket五种I/O模型之完成端口模型
weixin_45317033的博客
11-29 1472
前面几章已经分别介绍了window下socket 网络编程的几种模式，今天简单的介绍一下最后一个模型：完成端口（completionPort）模型。 关于他的一些优点网上有一堆，这边我也不再一一介绍，点而言之就是他充分利用内核对象的调度，只使用少量的几个线程来梳理和客户端所有通信，最大限度的提高了网络通信的性能。下面简单介绍一下主要涉及主要函数。 最优线程数 根据实际应用中发现，Cup核数*2+2这个数量是最优线程数（网上查询到的，我也不知道原因），获取系统内核数可调用 VOID GetSystemInfo
socket编程之完成端口(附一个简单的IOCP例子)
yangfm315的专栏
06-17 4140
“完成端口”模型是迄今为止最为复杂的—种I/O模型。然而。假若—个应用程序同时需要管理为数众多的套接字，那么采用这种模型。往往可以达到最佳的系统性能,然而不幸的是,该模型只适用于以下操作系统(微软的)：Windows NT和Windows 2000操作系统。因其设计的复杂性，只有在你的应用程序需要同时管理数百乃至上千个套接字的时候、而且希望随着系统内安装的CPU数量的增多、应用程序的性能也可以线性
广州大学计算机网络实验报告
06-19
【广州大学计算机网络实验报告】 本实验报告涵盖了计算机网络中的多个关键知识点，旨在通过实践加深学生对网络原理的理解。以下是报告的主要内容： 1. **Windows网络测试工具**：在Windows操作系统中，内置了一些...
计算机网络高级软件编程
03-29
本资源"计算机网络高级软件编程"提供了一系列网络协议的代码样本，为开发者提供了深入理解和实践这些协议的宝贵机会。下面，我们将详细探讨网络编程、网络协议以及计算机网络等相关知识点。 1. 网络编程：网络编程...
计算机网络联考复习题详细
最新发布
12-23
计算机网络联考复习题主要涵盖了计算机网络的基础概念、协议、设备和通信方式等多个方面。以下是对部分题目涉及知识点的详细解析： 1. 全双工通信方式：全双工允许数据在两个方向上同时传输，这与半双工通信不同，...
高性能的socket通讯服务器（完成端口模型--IOCP）
08-04
很多人费尽心思，都没有找到一个完美的 I/O CP 例程，甚至跟人于误解，先将本人编写的例程公布出来，希望对那些苦苦寻觅的人带来收获。本例程可以作为初学者的学习之用，亦可以作为大型服务程序的通讯模块。其处理速度可以说，优化到了极点。如果理解了本例程的精髓，加上一个高效的通讯协议，你完全可以用它来构建一个高性能的通讯服务器。
使用IOCP完成端口和SOCKET封装的成熟异步TCP类
01-18
使用IOCP完成端口和SOCKET封装的异步TCP类。 支持客户端和服务器的常用TCP接口：绑定Bind、监听Listen、接收Recv、连接Conn、发送Send、关闭Close。所有接口均使用异步回调的方式处理，内部实现使用Windows下性能最高的IOCP完成端口网络模型，并很好地处理了多线程安全和同步问题。 线程创建和事件信号量等地方用到了MFC的类，如果项目不支持MFC，可以把这些地方替换成WindowsAPI的方式。 代码是从成熟项目中分离出来的，能达到很高的性能和网络吞吐量，并且稳定无BUG。
手把手教你玩转网络编程模型之完成端口(CompletionPort)篇
03-05
想学习windows网络编程技术，这篇奇文一定不能错过哦！
经过封装的IOCP完成端口模型客户端
02-04
经过封装的IOCP完成端口模型客户端。 主要功能有发送普通文本数据，传输文件，下载文件
把socket IOCP完成端口网络通信模型封装成c++类.zip
03-30
把socket IOCP网络通信模型封装成c++类.zip
 Windows socket之IO完成端口（IOCP）模型开发
系统运维
01-21 327
Windowssocket之IO完成端口（IOCP）模型开发 IO完成端口是一种内核对象。利用完成端口，套接字应用程序能够管理数百上千个套接字。应用程序创建完成端口对象后，通过指定一定数量的服务线程，为已经完成的重叠IO操作提供服务。该模型可以达到最后的系统性能。 完成端口是一种真正意义上的异步模型。在重叠IO模型中，当Windowssocket应用程序在调用WSARecv函数后立即返回，...
io模型之异步事件模型
weixin_61899680的博客
04-06 799
异步事件模型简单实现
（四）Windows网络模型之完成端口模型详解
DongZhaoCheng
08-08 1123
完成端口模型是重叠IO模型的升级版，它解决了重叠IO模型中线程过多导致效率下降的问题。 在完成端口模型中，我们新创建一个完成端口变量，并将所有的socket(包括服务器socket和客户端通信socket)都绑定到完成端口上。然后使用AcceptEx()、WSARecv()、WSASend()函数异步投递相应的任务，等任务完成后操作系统将完成通知放进通知队列中。 之后程序员创建合理数目的线程，在线程函数中取出通知队列的头部，然后分析并分类处理。 该模型所有函数执行部分都是异步的，而且不存在线程滥用问题
windows socket网络编程六：完成端口模型
c++小白的博客
01-05 1643
文章目录分析服务器创建完成端口绑定端口与SOCKET创建线程线程内部代码投递accept、send、recv运行结果模型流程图源码链接 分析 我们的重叠IO模型还有什么问题吗？ 去掉我编写时候的逻辑bug，就网络模型来说主要问题还有： 循环询问，延迟高，做了很多无用功 采用多线程，数量可能太多，我们很难管理，切换线程消耗大量cpu资源/时间 那最优线程数量是多少？ 网上的几种答案： CPU核数 CPU核数*2 CPU核数*2+2 其中CPU核数*2+2 这个数量，是根据实际应用中的经验得来。线程函
计算机网络协议与端口详解
"该资源是一份关于计算机网络协议和端口知识的普及介绍，由范营营在2014年7月2日进行汇报。报告涵盖了网络协议的概述、应用层、传输层、互联层和网络接口层的协议，以及计算机通信的基本原理和不同类型的通信方式。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值