一个基于事件模型的socket封装类CEventSocket

最新推荐文章于 2023-06-25 17:17:41 发布
最新推荐文章于 2023-06-25 17:17:41 发布
阅读量2.5k 收藏 1
点赞数
分类专栏： 网络编程 文章标签： socket null pascal winapi events 工作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yebeans/article/details/1547523
版权
这是以前仿照MFC中的CAsyncSocket类写的一个基于事件模型的封装类~用法跟CAsyncSocket差不多,派生并重写接口.不同的是,这里会生成一个新的工作线程并在最大64个socket上进行操作.不过有些地方感觉还是不完善(比如错误代码处理上面还有其他什么不知道的地方),也不知道有没有必要写文档.贴出来大家看看有什么需要改进的,谢谢留言~(目前只测试了tcp连接的,可以正常工作)

//EventSocket.h  //from sizhizheng.blogchina.com

#pragma once
#include
#define STOP 0
#define RUN 1
#define PAUSE 2
#define MaxState PAUSE

class CEventSocket   //from sizhizheng.blogchina.com
{

protected:
 int sAf,sType,sProtocol,sPort;    //socket协议族，类型，协议 ,监听端口
 UINT statConn;       //连接状态
 long sNetworkEvents;      //关联事件

 SOCKET   m_SocketArr[MAXIMUM_WAIT_OBJECTS];
 WSAEVENT m_EventArr[MAXIMUM_WAIT_OBJECTS];

 CRITICAL_SECTION csSockArr;  //socket数组访问临界区


public:

 int      m_iTotalConn;  //socket计数


 CEventSocket(void);
 ~CEventSocket(void);

 static bool __stdcall EventSocketInit(WSADATA* lpwsaData = NULL);
 static DWORD WINAPI WorkThread(LPVOID lpObject);//工作线程

protected:  //处理接口
 virtual void OnReceive(int nNum,int /*nErrorCode*/);
 virtual void OnSend(int nNum,int /*nErrorCode*/);
 virtual void OnOutOfBandData(int nNum,int /*nErrorCode*/);
 virtual void OnAccept(int nNum,int /*nErrorCode*/);
 virtual void OnConnect(int nNum,int /*nErrorCode*/);
 virtual void OnClose(int nNum,int /*nErrorCode*/);
 
public:

 virtual bool Create(int af,int type,int protocol,long NetworkEvents);
 virtual bool NewSocket(SOCKET s=INVALID_SOCKET);               //添加套接字
 virtual bool NewLisSock(int nPort,int nConnectionBacklog=5);   //添加监听监听套接字  

 bool Listen(int nNum=0,int nConnectionBacklog=5);
 virtual SOCKET Accept(int nNum=0,SOCKADDR* lpSockAddr=NULL, int* nSockAddrLen=NULL);

 bool Bind(UINT nSocketPort, LPSTR lpszSocketAddress = NULL,int nNum=0);
 bool Bind (int nNum,const SOCKADDR* lpSockAddr, int nSockAddrLen);

 bool Connect(int nNum,LPSTR lpszHostAddress, UINT nHostPort);
 bool Connect(int nNum,const SOCKADDR* lpSockAddr, int nSockAddrLen);

 virtual int Send(int nNum,const void* lpBuf, int nBufLen, int nFlags=0);
 int SendTo(int nNum,const void* lpBuf, int nBufLen,
  UINT nHostPort, LPSTR lpszHostAddress = NULL, int nFlags = 0);
 int SendTo(int nNum,const void* lpBuf, int nBufLen,
  const SOCKADDR* lpSockAddr, int nSockAddrLen, int nFlags = 0);
 
 virtual int Receive(int nNum,void* lpBuf, int nBufLen, int nFlags=0);
 int ReceiveFrom(int nNum,void* lpBuf, int nBufLen,
  char* rSocketAddress, UINT& rSocketPort, int nFlags = 0);
 int ReceiveFrom(int nNum,void* lpBuf, int nBufLen,
  SOCKADDR* lpSockAddr, int* lpSockAddrLen, int nFlags = 0);

 bool GetPeerName(int nNum,CString& rPeerAddress, UINT& rPeerPort);
 bool GetPeerName(int nNum,SOCKADDR* lpSockAddr, int* lpSockAddrLen);
 
 bool GetSockName(int nNum,CString& rSocketAddress, UINT& rSocketPort);
 bool GetSockName(int nNum,SOCKADDR* lpSockAddr, int* lpSockAddrLen);

 bool SetSockOpt(int nNum,int nOptionName, const void* lpOptionValue,
  int nOptionLen, int nLevel = SOL_SOCKET);
 bool GetSockOpt(int nNum,int nOptionName, void* lpOptionValue,
  int* lpOptionLen, int nLevel = SOL_SOCKET);

 bool EventSelect(int nNum,long Events=FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE);

 int ShutDown(int nNum,int nHow);

 virtual int Close(int nNum);

 virtual void KillSocket(int nNum);

public:
 bool SetState(UINT state);
 UINT GetState(void);

 static int PASCAL GetLastError();
 

protected:
 virtual int SendToHelper(int nNum,const void* lpBuf, int nBufLen,
  const SOCKADDR* lpSockAddr, int nSockAddrLen, int nFlags);
 virtual int ReceiveFromHelper(int nNum,void* lpBuf, int nBufLen,
  SOCKADDR* lpSockAddr, int* lpSockAddrLen, int nFlags);
 virtual bool ConnectHelper(int nNum,const SOCKADDR* lpSockAddr, int nSockAddrLen

};
inline int CEventSocket::ShutDown(int nNum,int nHow)
{return shutdown(m_SocketArr[nNum],nHow);
}
inline bool CEventSocket::Bind(int nNum,const SOCKADDR* lpSockAddr, int nSockAddrLen)
 { return (SOCKET_ERROR != bind(m_SocketArr[nNum], lpSockAddr, nSockAddrLen)); }

inline int CEventSocket::SendTo(int nNum,const void* lpBuf, int nBufLen, const SOCKADDR* lpSockAddr, int nSockAddrLen, int nFlags)
 { return SendToHelper(nNum,lpBuf, nBufLen, lpSockAddr, nSockAddrLen, nFlags); }

inline int CEventSocket::ReceiveFrom(int nNum,void* lpBuf, int nBufLen, SOCKADDR* lpSockAddr, int* lpSockAddrLen, int nFlags)
 { return ReceiveFromHelper(nNum,lpBuf, nBufLen, lpSockAddr, lpSockAddrLen, nFlags); }

inline bool CEventSocket::Listen(int nNum,int nConnectionBacklog)
 { return (SOCKET_ERROR != listen(m_SocketArr[nNum], nConnectionBacklog)); }

inline bool  CEventSocket::Connect(int nNum,const SOCKADDR* lpSockAddr, int nSockAddrLen)
 { return ConnectHelper(nNum,lpSockAddr, nSockAddrLen); }

inline int PASCAL CEventSocket::GetLastError()
 { return WSAGetLastError(); }

inline bool CEventSocket::GetPeerName(int nNum,SOCKADDR* lpSockAddr, int* lpSockAddrLen)
 { return (SOCKET_ERROR != getpeername(m_SocketArr[nNum], lpSockAddr, lpSockAddrLen)); }

inline bool CEventSocket::GetSockName(int nNum,SOCKADDR* lpSockAddr, int* lpSockAddrLen)
 { return (SOCKET_ERROR != getsockname(m_SocketArr[nNum], lpSockAddr, lpSockAddrLen)); }

inline bool CEventSocket::SetSockOpt(int nNum,int nOptionName, const void* lpOptionValue, int nOptionLen, int nLevel)
 { return (SOCKET_ERROR != setsockopt(m_SocketArr[nNum], nLevel, nOptionName, (LPCSTR)lpOptionValue, nOptionLen)); }
inline bool CEventSocket::GetSockOpt(int nNum,int nOptionName, void* lpOptionValue, int* lpOptionLen, int nLevel)
 { return (SOCKET_ERROR != getsockopt(m_SocketArr[nNum], nLevel, nOptionName, (LPSTR)lpOptionValue, lpOptionLen)); }

 

 

//EventSocket.cpp //from sizhizheng.blogchina.com

#include "stdafx.h"
#include

#include "EventSocket.h"
#include
#include

 //from sizhizheng.blogchina.com

#pragma comment(lib, "ws2_32.lib")


bool __stdcall CEventSocket::EventSocketInit(WSADATA* lpwsaData)
{

 WSADATA wsaData;
 if (lpwsaData == NULL)
  lpwsaData = &wsaData;

 WORD wVersionRequested = MAKEWORD(1, 1);
 int nResult = WSAStartup(wVersionRequested, lpwsaData);
 if (nResult != 0)
  return FALSE;

 if (LOBYTE(lpwsaData->wVersion) != 1 || HIBYTE(lpwsaData->wVersion) != 1)
 {
  WSACleanup();
  return FALSE;
 }

 

 return TRUE;
}

CEventSocket::CEventSocket(void)
{
 m_iTotalConn = 0;
 SetState(RUN);

 memset(m_SocketArr,INVALID_SOCKET,sizeof(SOCKET)*MAXIMUM_WAIT_OBJECTS);
 memset(m_EventArr,0,sizeof(WSAEVENT)*MAXIMUM_WAIT_OBJECTS);
 InitializeCriticalSection(&csSockArr);


}
bool CEventSocket::Create(int af,int type,int protocol,long NetworkEvents)
{
 sProtocol = protocol;
 sType  = type;
 sAf   = af;
 sNetworkEvents=NetworkEvents;


 CreateThread(NULL, 0,WorkThread,this, 0, NULL);
 return true;
}
CEventSocket::~CEventSocket(void)
{
 int i=0;
 while(m_EventArr[i]!=0 &&i<=MAXIMUM_WAIT_OBJECTS)
 {
  WSACloseEvent(m_EventArr[i++]);
 }
 DeleteCriticalSection(&csSockArr);
 SetState(STOP);
}
DWORD WINAPI CEventSocket::WorkThread(LPVOID lpObject)
{
 int              ret, index,nErrorCode;
 WSANETWORKEVENTS NetworkEvents;

 CEventSocket *EventSock=(CEventSocket*) lpObject;

 while (EventSock->statConn!=STOP)
 {
  ret = WSAWaitForMultipleEvents(EventSock->m_iTotalConn, EventSock->m_EventArr, FALSE, 1000, FALSE);
  if (ret == WSA_WAIT_FAILED || ret == WSA_WAIT_TIMEOUT)
  {
   continue;
  }

  index = ret - WSA_WAIT_EVENT_0;

  WSAEnumNetworkEvents(EventSock->m_SocketArr[index], EventSock->m_EventArr[index], &NetworkEvents);


  if (NetworkEvents.lNetworkEvents & FD_READ)
  {
   nErrorCode=NetworkEvents.iErrorCode[FD_READ_BIT];
   EventSock->OnReceive(index,nErrorCode);

  }
  if (NetworkEvents.lNetworkEvents & FD_WRITE)
  {
   nErrorCode=NetworkEvents.iErrorCode[FD_WRITE_BIT];
   EventSock->OnSend(index,nErrorCode);

  }
  if (NetworkEvents.lNetworkEvents & FD_OOB)
  {
   nErrorCode=NetworkEvents.iErrorCode[FD_OOB_BIT];
   EventSock->OnOutOfBandData(index,nErrorCode);

  }
  if (NetworkEvents.lNetworkEvents & FD_ACCEPT)
  {
   nErrorCode=NetworkEvents.iErrorCode[FD_ACCEPT_BIT];
   EventSock->OnAccept(index,nErrorCode);

  }
  if (NetworkEvents.lNetworkEvents & FD_CONNECT)
  {
   nErrorCode=NetworkEvents.iErrorCode[FD_CONNECT_BIT];
   EventSock->OnConnect(index,nErrorCode);

  }

  if (NetworkEvents.lNetworkEvents & FD_CLOSE)
  {
   nErrorCode=NetworkEvents.iErrorCode[FD_CLOSE_BIT];
   EventSock->OnClose(index,nErrorCode);
  }
  if(EventSock->statConn==PAUSE)
   Sleep(1000);
 }

 return 0;
}

void CEventSocket::OnReceive(int nNum,int /*nErrorCode*/)
{
}

void CEventSocket::OnSend(int nNum,int /*nErrorCode*/)
{
}

void CEventSocket::OnOutOfBandData(int nNum,int /*nErrorCode*/)
{
}

void CEventSocket::OnAccept(int nNum,int /*nErrorCode*/)
{
}

void CEventSocket::OnConnect(int nNum,int /*nErrorCode*/)
{

}

void CEventSocket::OnClose(int nNum,int /*nErrorCode*/)
{
}


bool CEventSocket::NewSocket(SOCKET s)
{
 EnterCriticalSection(&csSockArr);
 if (m_SocketArr[m_iTotalConn] != INVALID_SOCKET || m_iTotalConn>=MAXIMUM_WAIT_OBJECTS)
 {

  LeaveCriticalSection(&csSockArr);
  return false;
 }

 if (s==INVALID_SOCKET)
 {
  m_SocketArr[m_iTotalConn]=socket(sAf,sType,sProtocol);
 }else {
  m_SocketArr[m_iTotalConn]=s;
 }

 if(m_EventArr[m_iTotalConn]==0)
 {
  m_EventArr[m_iTotalConn]=WSACreateEvent();
 }
 EventSelect(m_iTotalConn,sNetworkEvents);

 m_iTotalConn++;

 LeaveCriticalSection(&csSockArr);
 return true;

}
bool CEventSocket::NewLisSock(int nPort,int nConnectionBacklog)
{
 bool ret=true;
 if (0==nPort)
  SetLastError(WSAEINVAL);

 ret&=NewSocket();
 ret&=EventSelect(m_iTotalConn-1,FD_ACCEPT|FD_CLOSE);
 ret&=Bind(nPort);
 ret&=Listen(m_iTotalConn-1, nConnectionBacklog);

 return ret;

};

SOCKET CEventSocket::Accept(int nNum,SOCKADDR* lpSockAddr, int* nSockAddrLen)
{
 return accept(m_SocketArr[nNum],lpSockAddr,nSockAddrLen);
}
bool CEventSocket::Bind(UINT nSocketPort, LPSTR lpszSocketAddress,int nNum)
{

 SOCKADDR_IN sockAddr;
 memset(&sockAddr,0,sizeof(sockAddr));

 

 sockAddr.sin_family = AF_INET;

 if (lpszSocketAddress == NULL)
 {
  sockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
 }
 else
 {
  DWORD lResult = inet_addr(lpszSocketAddress);
  if (lResult == INADDR_NONE)
  {
   WSASetLastError(WSAEINVAL);
   return FALSE;
  }
  sockAddr.sin_addr.s_addr = lResult;
 }

 sockAddr.sin_port = htons((u_short)nSocketPort);

 return Bind(nNum,(SOCKADDR*)&sockAddr, sizeof(sockAddr));
}
bool CEventSocket::Connect(int nNum,LPSTR lpszHostAddress, UINT nHostPort)
{
 if (lpszHostAddress == NULL)
 {
  return FALSE;
 }

 SOCKADDR_IN sockAddr;
 memset(&sockAddr,0,sizeof(sockAddr));


 sockAddr.sin_family = AF_INET;
 sockAddr.sin_addr.s_addr = inet_addr(lpszHostAddress);

 if (sockAddr.sin_addr.s_addr == INADDR_NONE)
 {
  LPHOSTENT lphost;
  lphost = gethostbyname(lpszHostAddress);
  if (lphost != NULL)
   sockAddr.sin_addr.s_addr = ((LPIN_ADDR)lphost->h_addr)->s_addr;
  else
  {
   WSASetLastError(WSAEINVAL);
   return FALSE;
  }
 }

 sockAddr.sin_port = htons((u_short)nHostPort);

 return Connect(nNum,(SOCKADDR*)&sockAddr, sizeof(sockAddr));
}

bool CEventSocket::ConnectHelper(int nNum,const SOCKADDR* lpSockAddr, int nSockAddrLen)
{
 return connect(m_SocketArr[nNum], lpSockAddr, nSockAddrLen) != SOCKET_ERROR;
}

int CEventSocket::Send(int nNum,const void* lpBuf, int nBufLen, int nFlags)
{
 return send(m_SocketArr[nNum], (LPSTR)lpBuf, nBufLen, nFlags);
}

int CEventSocket::Receive(int nNum,void* lpBuf, int nBufLen, int nFlags)
{
 return recv(m_SocketArr[nNum], (LPSTR)lpBuf, nBufLen, nFlags);
}

 

int CEventSocket::SendTo(int nNum,const void* lpBuf, int nBufLen, UINT nHostPort, LPSTR lpszHostAddress, int nFlags)
{
 SOCKADDR_IN sockAddr;

 memset(&sockAddr,0,sizeof(sockAddr));

 

 sockAddr.sin_family = AF_INET;

 if (lpszHostAddress == NULL)
  sockAddr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
 else
 {
  sockAddr.sin_addr.s_addr = inet_addr(lpszHostAddress);
  if (sockAddr.sin_addr.s_addr == INADDR_NONE)
  {
   LPHOSTENT lphost;
   lphost = gethostbyname(lpszHostAddress);
   if (lphost != NULL)
    sockAddr.sin_addr.s_addr = ((LPIN_ADDR)lphost->h_addr)->s_addr;
   else
   {
    WSASetLastError(WSAEINVAL);
    return SOCKET_ERROR;
   }
  }
 }

 sockAddr.sin_port = htons((u_short)nHostPort);

 return SendTo(nNum,lpBuf, nBufLen, (SOCKADDR*)&sockAddr, sizeof(sockAddr), nFlags);
}
int CEventSocket::SendToHelper(int nNum,const void* lpBuf, int nBufLen, const SOCKADDR* lpSockAddr, int nSockAddrLen, int nFlags)
{
 return sendto(m_SocketArr[nNum], (LPSTR)lpBuf, nBufLen, nFlags, lpSockAddr, nSockAddrLen);
}

 

int CEventSocket::ReceiveFrom(int nNum,void* lpBuf, int nBufLen, char* rSocketAddress, UINT& rSocketPort, int nFlags)
{
 SOCKADDR_IN sockAddr;

 memset(&sockAddr, 0, sizeof(sockAddr));

 int nSockAddrLen = sizeof(sockAddr);
 int nResult = ReceiveFrom(nNum,lpBuf, nBufLen, (SOCKADDR*)&sockAddr, &nSockAddrLen, nFlags);
 if(nResult != SOCKET_ERROR)
 {
  rSocketPort = ntohs(sockAddr.sin_port);
  rSocketAddress = inet_ntoa(sockAddr.sin_addr);
 }
 return nResult;
}
int CEventSocket::ReceiveFromHelper(int nNum,void* lpBuf, int nBufLen, SOCKADDR* lpSockAddr, int* lpSockAddrLen, int nFlags)
{
 return recvfrom(m_SocketArr[nNum], (LPSTR)lpBuf, nBufLen, nFlags, lpSockAddr, lpSockAddrLen);
}

int CEventSocket::Close(int nNum)
{
 if (m_SocketArr[nNum]!=INVALID_SOCKET)
 {

  int ret=closesocket(m_SocketArr[nNum]);
  KillSocket(nNum);
  return ret;

 }else{
  return WSAENOTSOCK;
 }

}
void CEventSocket::KillSocket(int nNum)
{
 EnterCriticalSection(&csSockArr);

 m_iTotalConn--;
 m_SocketArr[nNum]=m_SocketArr[m_iTotalConn];


 EventSelect(nNum,sNetworkEvents);
 m_SocketArr[m_iTotalConn]=INVALID_SOCKET;


 LeaveCriticalSection(&csSockArr);
}


bool CEventSocket::GetPeerName(int nNum,CString& rPeerAddress, UINT& rPeerPort)
{
 SOCKADDR_IN sockAddr;
 memset(&sockAddr, 0, sizeof(sockAddr));

 int nSockAddrLen = sizeof(sockAddr);
 bool bResult = GetPeerName(nNum,(SOCKADDR*)&sockAddr, &nSockAddrLen);
 if (bResult)
 {
  rPeerPort = ntohs(sockAddr.sin_port);
  rPeerAddress = inet_ntoa(sockAddr.sin_addr);
 }
 return bResult;
}

bool CEventSocket::GetSockName(int nNum,CString& rSocketAddress, UINT& rSocketPort)
{
 SOCKADDR_IN sockAddr;
 memset(&sockAddr, 0, sizeof(sockAddr));

 int nSockAddrLen = sizeof(sockAddr);
 bool bResult = GetSockName(nNum,(SOCKADDR*)&sockAddr, &nSockAddrLen);
 if (bResult)
 {
  rSocketPort = ntohs(sockAddr.sin_port);
  rSocketAddress = inet_ntoa(sockAddr.sin_addr);
 }
 return bResult;
}

bool CEventSocket::EventSelect(int nNum,long Events)
{

 if(m_SocketArr[nNum] == INVALID_SOCKET)
 {
  WSASetLastError(WSAENOTSOCK);
  return false;
 }


 return WSAEventSelect(m_SocketArr[nNum],m_EventArr[nNum], Events) != SOCKET_ERROR;

}

bool CEventSocket::SetState(UINT state)
{
 if (state {
  statConn=state;
  return true;
 }
 return false;
}
UINT CEventSocket::GetState(void)
{
 return statConn;
}

 
yebeans
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C# 一个高性能异步socket封装库的实现思路
遇见--专栏
09-18 9558
前言 socket是软件之间通讯最常用的一种方式。c#实现socket通讯有很多中方法，其中效率最高就是异步通讯。 异步通讯实际是利用windows完成端口（IOCP）来处理的，关于完成端口实现原理，大家可以参考网上文章。 我这里想强调的是采用完成端口机制的异步通讯是windows下效率最高的通讯方式，没有之一！   异步通讯比同步通讯处理要难很多，代码编写中会遇到许多“坑“。如果没有经...
Socket网络事件通讯模型
03-02
socket通讯事件驱动模型，客户端、服务器端
freeswitch模块之event_socket
weixin_34405332的博客
09-27 899
这是我之前整理的关于freeswitch mod_event_socket的相关内容，这里记录下，也方便我以后查阅。 mod_event_socket以socket的形式，对外提供控制FS一种途径， 缺省的IP是127.0.0.1，TCP端口是8021，可以在外部通过sokcet执行API/APP命令。 连接模式 连接分两种模式： inbound/outboundmod_event_sock...
[C#]事件驱动的SOCKET类
netcaoniao的专栏
08-12 1682
using System;  using System.Collections.Generic;  using System.Text;  using System.Net.Sockets;  using System.Threading;  using log4net;    namespace CallOut  {      class CallCenterCom      {        
Windows socket之WSAEventSelect模型
系统运维
01-07 352
WSAEventSelect模型 WSAEventSelect模型是Windowssocekts提供的另一个有用异步IO模型。该模型允许在一个或多个套接字上接收以事件为基础的网络事件通知。Windowssockets应用程序可以通过调用WSAEventSelect函数，将一个事件与网络事件集合关联起来。当网络事件发生时，应用程序以事件的形式接收网络事件通知。 WSAEventSe...
Socket异步编程之基于事件
Segen_Jaa的专栏
10-25 5265
本例采用Socket实现局域网通信。 开发环境：XP+VS2005+MFC 关键API：WSACreateEvent、WSAEventSelect、WSACloseEvent、WSAWaitForMultipleEvents、WSAEnumNetworkEvents。 参考：http://blog.csdn.net/mlite/article/details/699340。
C# socket封装类和组件含例程全部开源
06-17
它可能包含一个线程池或者异步处理模型，以处理多个并发的客户端连接。 4. **例程**：这些例程展示了如何使用封装后的Socket类进行实际的网络通信，可能涵盖了TCP连接、UDP广播、文件传输等多种应用场景。 5. **...
[VB]一个Socket连接类，封装了Winsock API
03-17
这个名为"一个Socket连接类，封装了Winsock API"的VB类，可能包含以下核心功能： 1. 初始化与配置：类的初始化通常涉及设置Winsock控件的基本属性，如本地主机地址、端口号等。这一步确保Socket正确绑定到特定的...
C#实现Socket异步通信完整封装库源码
04-17
封装库可能会创建一个线程池，当有新的连接请求时，将该请求放入队列，由线程池中的工作线程处理，避免阻塞主线程，提高系统的并发能力。 `SocketClient`则代表了客户端的连接，它负责发起连接请求，并与服务器进行...
C++ socket 基本功能跨平台封装（好用）
12-06
真正可以使用的平台无关性的 C++ socket wrapper，没有做任何多余的事情，仅仅对 socket 的基本功能进行了平台无关性的封装，简洁原生。封装了：setoption, connect, close, send, recv, sendto, recvfrom， accept...
socket 选择模型
04-18
网络通信 select 模型 C++ 代码
fs event_socket
weixin_34319817的博客
02-07 444
mod_event_socket     Skip to end of metadata   Created by John Boteler, last modified by Niek Vlessert on Nov 14, 2014 Go to start of metadata   About mod_event_socket is ...
FreeSwitch(十八)：EventSocket
科大小笨的博客
07-15 2016
一、架构 与Lua之类的嵌人式语言不同,通过 Event Socket方式,可以使用运行在 FREESWITCH外部的程序控制 Freeswitch。它可以通过 Socket方式使用 FREESWITCH提供的所有的APp程序和API命令。 1.1、外连模式 FREESWITCH是一个B2BUA,当Bob呼叫 Alice时,首先电话会到达 FREESWITCH(通过SIP),建立个单腿的 Channel(a-leg),然后电话进人路由状态, FREESWITCH查找 D...
event socket读写
安子自语
07-14 1335
static void test_multiple(void) { struct event ev, ev2; int i; /* Multiple read and write test */ setup_test("Multiple read/write: "); memset(rbuf, 0, sizeof(rbuf)); for (i = 0; i wbuf[i
libevent（10）使用event处理socket连接
最新发布
06-25 719
通过event处理socket连接，并进行一些简单的数据处理。
PHP基于event的webSocket连接实例
tqtxk_liqiang的专栏
11-30 1176
php的socket编程方式有多种方式，本文只介绍以下三种 php自带select()方法 基于pecl的event库(linux需要安装libevent开发库) 基于pecl的libevent库(linux需要安装libevent开发库)本文只介绍event的实现 event是PECL在libevent基础上实现基于事件驱动的扩展库，它有着高效并发处理能力。所以本文基于它来实现一个H5的webs
socket编程 - Event扩展的使用（一）
猛犸象
05-18 1364
PHP默认没有提供epoll的函数，需要安装llibevent或者event扩展，建议使用event扩展。 不管是llibevent或者event扩展，都需要先安装libevent程序来提供api。 安装教程 https://blog.csdn.net/raoxiaoya/article/details/106170760 epoll实现原理 https://blog.csdn.net/raoxiaoya/article/details/106185479 event扩展提供的内容 要明确的一点是，eve
Socketserver，Event的使用
weixin_43183295的博客
11-15 546
回顾 网络 IO模型 1.阻塞IO模型 多线程 多进程 线程池 进程池 全是阻塞IO 2.非阻塞IO 协程是一种非阻塞IO 1.setblocking(False) 将阻塞修改为非阻塞 2.一旦是非阻塞 在执行accept recv send 就会立马尝试读写数据 一旦数据没准备好就抛异常 3.捕获...
windows Socket编程之EventSelect网络模型
Timmiy的博客
08-11 4056
前一篇文章我们讲了select网络模型，它解决了有N个客户端连接，就有N+1个线程的问题，现在我们只需要2个线程就能搞定了。但是，我们的服务端仅仅是这样的话，它的效率还是非常低的。在select模型中，我们在工作者线程里边调用了select函数来判断是否有数据到来了（有信号了），如果没有信号，select就会卡在这里，虽然我们可以给它一个超时时间，但是它在底层还是调用了sleep函数。所以它浪费了CPU的时钟周期，由于我们不知道客户是什么发送数据过来，可能是1秒，可能是1小时，也有可能是1天，所有等待数据到
使用socket封装一个java操作redis的工具类
05-24
好的，以下是一个简单的使用Socket封装的Java操作Redis的工具类： ```java import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.Socket; import java.util....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值