16线程同步和异步套接字

最新推荐文章于 2023-08-29 17:20:16 发布
最新推荐文章于 2023-08-29 17:20:16 发布
阅读量946 收藏 1
点赞数
分类专栏： 转载的孙鑫vc++视频笔记 文章标签： MFC VC++ 
<a target=_blank href="http://blog.sina.com.cn/s/articlelist_1815328704_0_1.html">http://blog.sina.com.cn/s/articlelist_1815328704_0_1.html</a>

第16课
1.事件对象：来实现线程的同步。与互斥对象一样均属于内核对象。
            当人工重置有信号时，所有线程均得到信号，所以不能设为人工重置。代码就不贴了。
            通过创建匿名的事件对象，也可以让一个程序只能运行一个实例。 
2.关键代码段实现线程的同步：类似公用电话亭，只有当电话亭里面没人了，其它人才可以再进去打电话。用了4个函数，这种方法比较简单！但缺点是如果使用了多少关键代码码，容易赞成线程的死锁
3.线程死锁，用关键代码示例，用了两个临界区对象，实战中要注意避免这种错误！

4.使用异步套接字编写网络聊天室
  1)加载套接字库，进行版本协商，包含头文件，链接库文件，这次请示的是2.2版本！
  2）在类CChatDlg中增加一个成员变量m_socket,在析构函数中释放这个变量
  3）利用WSASocket()创建套接字（数据报类型的UDP型的）
  4）然后调用WSAAsyncSelect(m_socket,m_hWnd,UM_SOCK,FD_READ)为网络事件定义消息！此时如果发生FD_READ消息，系统会发送UM_SOCK消息给应用程序！程序并不会阻塞在这儿了！
  以上是在BOOL CChatDlg::OnInitDialog()完成
  5）然后完成消息响应！
  头文件中：#define UM_SOCK  WM_USER+1
afx_msg void OnSock(WPARAM,LPARAM);
   源文件中：
    ON_MESSAGE(UM_SOCK,OnSock)
    实现消息响应函数：void CChatDlg::OnSock(WPARAM wParam,LPARAM lParam)
{
switch(LOWORD(lParam))
{
case FD_READ:
  WSABUF wsabuf;
  wsabuf.buf=new char[200];
  wsabuf.len=200;
  DWORD dwRead;
  DWORD dwFlag=0;
  SOCKADDR_IN addrFrom;
  int len=sizeof(SOCKADDR);
  CString str;
  CString strTemp;
  HOSTENT *pHost;
  if(SOCKET_ERROR==WSARecvFrom(m_socket,&wsabuf,1,&dwRead,&dwFlag,
      (SOCKADDR*)&addrFrom,&len,NULL,NULL))
  {
   MessageBox("接收数据失败！");
   return;
  }
  pHost=gethostbyaddr((char*)&addrFrom.sin_addr.S_un.S_addr,4,AF_INET);
  //str.Format("%s说 :%s",inet_ntoa(addrFrom.sin_addr),wsabuf.buf);
  str.Format("%s说 :%s",pHost->h_name,wsabuf.buf);
  str+="\r\n";
  GetDlgItemText(IDC_EDIT_RECV,strTemp);
  str+=strTemp;
  SetDlgItemText(IDC_EDIT_RECV,str);
  break;
}
}
OK！
      6）完成数据发送的功能！
      void CChatDlg::OnBtnSend()
{
// TOD Add your control notification handler code here
DWORD dwIP;
CString strSend;
WSABUF wsabuf;
DWORD dwSend;
int len;
CString strHostName;
SOCKADDR_IN addrTo;
HOSTENT* pHost;
if(GetDlgItemText(IDC_EDIT_HOSTNAME,strHostName),strHostName=="")
{
  ((CIPAddressCtrl*)GetDlgItem(IDC_IPADDRESS1))->GetAddress(dwIP);
  addrTo.sin_addr.S_un.S_addr=htonl(dwIP);
}
else
{
  pHost=gethostbyname(strHostName);
  addrTo.sin_addr.S_un.S_addr=*((DWORD*)pHost->h_addr_list[0]);
}
addrTo.sin_family=AF_INET;
addrTo.sin_port=htons(6000);
GetDlgItemText(IDC_EDIT_SEND,strSend);
len=strSend.GetLength();
wsabuf.buf=strSend.GetBuffer(len);
wsabuf.len=len+1;
SetDlgItemText(IDC_EDIT_SEND,"");
if(SOCKET_ERROR==WSASendTo(m_socket,&wsabuf,1,&dwSend,0,
   (SOCKADDR*)&addrTo,sizeof(SOCKADDR),NULL,NULL))
{
  MessageBox("发送数据失败！");
  return;
}
}
      7）完成将主机名转换为IP地址的功能，以前将IP地址转换为主机名的功能
嘿嘿，单线程的聊天室创建完毕！性能并且非常出色！
 
 

//---------------------------------------------------------------------------
事件对象
事件对象也属于内核对象，包含一个使用计数，一个用于指明该事件是一个自动重置的事件还是一个人工重置的事件的布尔值，另一个用于指明该事件处于已通知状态还是为通知状态的布尔值
有两种不同类型的事件对象。一种是人工重置的事件，另一种是自动重置的事件，当人工重置的事件得到通知时，等待该事件的所有线程均变为可调度线程。当一个自动重置的事件得到通知时，等待该事件的线程中只有一个线程变为可调度线程。
HANDLE CreateEvent(
  LPSECURITY_ATTRIBUTES lpEventAttributes,
                      // pointer to security attributes，指定安全属性
  BOOL bManualReset,  // flag for manual-reset event
 //为TRUE表示手动，否则为自动，看上边文字说明
  BOOL bInitialState, // flag for initial state
 //为TRUE表示有信号
  LPCTSTR lpName      // pointer to event-object name
);
事件对象代码如下（经本人修改，此代码与视频源码有一些差别）：
#include <windows.h>
#include <iostream.h>

DWORD WINAPI Fun1Proc(
  LPVOID lpParameter   // thread data
);
DWORD WINAPI Fun2Proc(
  LPVOID lpParameter   // thread data
);
int tickets=100;
HANDLE g_hEvent;

void main()
{
  HANDLE hThread1;
  HANDLE hThread2;

  g_hEvent=CreateEvent(NULL,FALSE,true,"tickets");
  ResetEvent(g_hEvent);//重置事件
  //g_hEvent=CreateEvent(NULL,FALSE,false,"tickets");

  if(g_hEvent)
  {
    if(ERROR_ALREADY_EXISTS==GetLastError())
    {
      cout<<"only instance can run!"<<endl;
      return;
    }
  }

  hThread1=CreateThread(NULL,0,Fun1Proc,NULL,0,NULL);
  hThread2=CreateThread(NULL,0,Fun2Proc,NULL,0,NULL);
  CloseHandle(hThread1);
  CloseHandle(hThread2);

  //g_hEvent=CreateEvent(NULL,FALSE,FALSE,NULL);

  SetEvent(g_hEvent);

  Sleep(4000);
  CloseHandle(g_hEvent);
}

DWORD WINAPI Fun1Proc(
  LPVOID lpParameter   // thread data
)
{
  while(TRUE)
  {
    WaitForSingleObject(g_hEvent,INFINITE);// 等待事件置位
//    ResetEvent(g_hEvent);
    if(tickets>0)
    {
      Sleep(1);
      cout<<"thread1 sell ticket : "<<tickets--<<endl;
    }
    else
      break;
    SetEvent(g_hEvent);// 处理完成后即将事件对象置位
  }
  
  return 0;
}
DWORD WINAPI Fun2Proc(
  LPVOID lpParameter   // thread data
)
{
  
  while(TRUE)
  {
    WaitForSingleObject(g_hEvent,INFINITE);
//    ResetEvent(g_hEvent);
    if(tickets>0)
    {
      Sleep(1);
      cout<<"thread2 sell ticket : "<<tickets--<<endl;
    }
    else
      break;
    SetEvent(g_hEvent);
  }
  
  return 0;
}

只有当 g_hEvent=CreateEvent(NULL,FALSE,TRUE,"ticket");第四个参数有值时才能进行事件对象的判断：
 if(g_hEvent)
 {
  if(ERROR_ALREADY_EXISTS==GetLastError())
  {
   cout<<"Only one instance can runs!"<<endl;
   return;
  }
 }

//---------------------------------------------------------------------------

关键代码段
关键代码段（临界区）工作在用户方式下。
关键代码段（临界区）是指一个小代码段，在代码能够执行前，它必须独占对某资源的访问权。
VOID InitializeCriticalSection(
  LPCRITICAL_SECTION lpCriticalSection   // address of critical
                                         // section object
);
VOID DeleteCriticalSection(
  LPCRITICAL_SECTION lpCriticalSection   // pointer to critical
                                         // section object
);
VOID EnterCriticalSection(
  LPCRITICAL_SECTION lpCriticalSection   // pointer to critical
                                         // section object
);
VOID LeaveCriticalSection(
  LPCRITICAL_SECTION lpCriticalSection   // address of critical
                                         // section object
);
原代码如下：
#include "windows.h"
#include "iostream.h"
int ticket=100;

DWORD WINAPI Fun1Proc(LPVOID lpParameter);
DWORD WINAPI Fun2Proc(LPVOID lpParameter);
CRITICAL_SECTION g_cs;
void main()
{ 
  
InitializeCriticalSection(&g_cs);

 HANDLE thread1=CreateThread(NULL,0,Fun1Proc,NULL,0,NULL);
 HANDLE thread2=CreateThread(NULL,0,Fun2Proc,NULL,0,NULL);
 CloseHandle(thread1);
 CloseHandle(thread2);

 Sleep(4000);
 DeleteCriticalSection(&g_cs);
}
DWORD WINAPI Fun1Proc(LPVOID lpParameter)
{ 
 while(TRUE)
 {
  EnterCriticalSection(&g_cs);
  if(ticket>0)
  {
   cout<<"thread1 sells : "<<ticket--<<endl;
   Sleep(1);
  }
  else break;
  LeaveCriticalSection(&g_cs);
 }
 return 0;
}
DWORD WINAPI Fun2Proc(LPVOID lpParameter)
{ 
 while(TRUE)
 {
  EnterCriticalSection(&g_cs);
  if(ticket>0)
  {
   cout<<"thread2 sells : "<<ticket--<<endl;
   Sleep(1);
  }
  else break;
  LeaveCriticalSection(&g_cs);
 }
 return 0;
}

互斥对象、事件对象与关键代码段的比较
互斥对象和事件对象属于内核对象，利用内核对象进行线程同步，速度较慢，但利用互斥对象和事件对象这样的内河对象，可以在多个进程中的各个线程间进行同步。
关键代码段时工作在用户方式下，同步速度较快，但在使用关键代码段时，很容易进入死锁状态，因为在等待进入关键代码段时无法设定超时值
//---------------------------------------------------------------------------


基于消息的异步套接字
Windows套接字在两种模式下执行I/O操作，阻塞和非阻塞。在阻塞模式下，在I/O操作完成前，执行操作的Winsock函数会一直等待下去，不会立即返回程序（将控制权交还给程序）。而在非阻塞模式下，Winsock函数无论如何都会立即返回。
Windows Sockets为了支持Windows消息驱动机制，使应用程序开发者能够方便地处理网络通信，它对网络事件采用了基于消息的异步存取策略。
Windows Sockets的异步选择函数WSAAsyncSelect()提供了消息机制的网络事件选择，当使用它登记的网络事件发生时，Windows应用程序相应的窗口函数将收到一个消息，消息中指示了发生的网络事件，以及与事件相关的一些信息。
Win32平台支持多种不同的网络协议，采用Winsock2就可以编写可直接使用任何一种协议的网络应用程序了。通过WSAEnumProtocols可以获得系统中安装的网络协议的的相关信息。
int WSAEnumProtocols (
  LPINT lpiProtocols,      //若为NULL，返回所有可用协议信息，
 //否则返回数组中所列协议信息。
  LPWSAPROTOCOL_INFO lpProtocolBuffer,  //WSAPROTOCOL_INFO用来存放或得到一个指定协议的完整信息
  ILPDWORD lpdwBufferLength     //指定传递给函数的缓冲区长度
);
SOCKET WSASocket (
  int af,                            
  int type,                          
  int protocol,                      
  LPWSAPROTOCOL_INFO lpProtocolInfo, 
  GROUP g,                           
  DWORD dwFlags                      
);
lpProtocolInfo 是指向WSAPROTOCOL_INFO结构体的指针，该结构定义了所创建的套接字的特性。如果为NULL，WinSock2.DLL使用前三个参数来决 定使用哪一个服务提供者，他选择能够支持规定的抵制族、套接字类型和协议值的第一个传输提供者。如果不为NULL，则套接字绑定到与指定的结构 WSAPROTOCOL_INFO相关的提供者
调用WSAAsyncSelect请求一个windows的基于消息的网络事件通知
int WSAAsyncSelect (
  SOCKET s,          
  HWND hWnd,         
  unsigned int wMsg, 
  long lEvent        
);
接收数据：
int WSARecvFrom (
  SOCKET s,     //标识套接字的描述符
  LPWSABUF lpBuffers,   //指向WSABUF的指针，每一个包含WSABUF包含一个        //缓冲区的指针和缓冲区的长度
  DWORD dwBufferCount,  //lpBuffers数组中WSABUF结构体的长度
  LPDWORD lpNumberOfBytesRecvd,  //如果接收操作立即完成，则为指向本次调用接受         //字节数的指针
  LPDWORD lpFlags,
  struct sockaddr FAR * lpFrom,  //指向重叠操作完成后存放原地址的缓冲区
  LPINT lpFromlen,   //指向From缓冲区大小的指针，制定了 lpFrom才需要
  LPWSAOVERLAPPED lpOverlapped, //指向WSAOVERLAPPED
  LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionROUTINE 
 //指向接收操作完成时调用的完成例程的指针
);


为了调用高版本的套接字，我们要调用WSAStartup来制定套接字版本：
在BOOL CChatApp::InitInstance()中添加代码如下：

WORD wVersionRequested;
 WSADATA wsaData;
 int err;
 
 wVersionRequested = MAKEWORD( 2, 2 );
 
 err = WSAStartup( wVersionRequested, &wsaData );
 if ( err != 0 )
 {
  return FALSE;
 }
 
 if ( LOBYTE( wsaData.wVersion ) != 2 ||
        HIBYTE( wsaData.wVersion ) != 2 )
 {
  WSACleanup( );
  return FALSE;
 }

接下来编写函数初始化套接字，步骤如下：
1。新建套接字
2。新建地址。
3。绑定
4。请求一个windows的基于消息的网络事件通知
5。在BOOL CChatDlg::OnInitDialog()中调用BOOL CChatDlg::InitSocket()

代码如下：
BOOL CChatDlg::InitSocket()
{
 m_socket=WSASocket(AF_INET,SOCK_DGRAM,0,NULL,0,0);
 if(INVALID_SOCKET=m_socket)
 {
  MessageBox("套接字创建失败");
  return FALSE;
 }
 SOCKADDR_IN addrSock;
 addrSock.sin_addr.S_un.S_addr=htonl(INADDR_ANY);
 addrSock.sin_family=AF_INET;
 addrSock.sin_port=htons(6000);
 if(SOCKET_ERROR==bind(m_socket,(SOCKADDR*)&addrSock,sizeof(SOCKADDR)))
 {
  MessageBox("绑定失败！");
  return FALSE;
 }
 if(SOCKET_ERROR==WSAAsyncSelect(m_socket,m_hWnd,UM_SOCK,FD_READ))
 {
  MessageBox("注册网络读取事件失败!");
  return FALSE;
 }
}
自定义消息响应函数步骤：
1。在ChatDlg.h中定义#define UM_SOCK  WM_USER+1
2。在 
 //{{AFX_MSG(CChatDlg)
 virtual BOOL OnInitDialog();
 afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
 afx_msg void OnPaint();
 afx_msg HCURSOR OnQueryDragIcon();
 //}}AFX_MSG
 DECLARE_MESSAGE_MAP()
中添加
afx_msg LRESULT OnSock(WPARAM wParam,LPARAM lParam);
//注意返回值类型
3。在
BEGIN_MESSAGE_MAP(CChatDlg, CDialog)
 //{{AFX_MSG_MAP(CChatDlg)
 ON_WM_SYSCOMMAND()
 ON_WM_PAINT()
 ON_WM_QUERYDRAGICON()
 //}}AFX_MSG_MAP
END_MESSAGE_MAP()
中添加消息映射
 ON_MESSAGE(UM_SOCK,OnSock)  //此处不加标点


4。实现消息响应函数
LRESULT CChatDlg::OnSock(WPARAM wParam,LPARAM lParam)
{
 switch(LOWORD(lParam))
 {
 case FD_READ:
  WSABUF wsabuf;
  wsabuf.buf=new char[200];
  wsabuf.len=200;
  DWORD dwRead;
  DWORD dwFlag=0;
  SOCKADDR_IN addrFrom;
  int len=sizeof(SOCKADDR);
  CString strTemp;
  CString str;
  
  if(SOCKET_ERROR==WSARecvFrom(m_socket,&wsabuf,1,&dwRead,&dwFlag,
      (SOCKADDR*)&addrFrom,&len,NULL,NULL))
  {
   MessageBox("接收数据失败!");
   return FALSE;
  }
  str.Format("%s speak : %s",inet_ntoa(addrFrom.sin_addr),wsabuf.buf);
  str+="\r\n";
  GetDlgItemText(IDC_EDIT_RECV,strTemp);
  str+=strTemp;
  SetDlgItemText(IDC_EDIT_RECV,str);
  break;
 }
 return 0;
}

注意，此程序的接收端和发送端是在同一个线程下完成的，如果我们采用阻塞套接字会因为接收函数的调用而使主线程暂停运行。这样我们采用异步选择的机制完成了主线程的接收端和发送端
如果我们不想总是输入IP地址而是想输入主机名，可以调用函数
struct hostent* FAR gethostbyname(
  const char* name
);
在对话框上新建一个文本框
代码：
 HOSTENT * pHost;
 GetDlgItemText(IDC_EDIT_HOSTNAME,strHostName);
 if(strHostName=="")
 {
  ((CIPAddressCtrl*)GetDlgItem(IDC_IPADDRESS))->GetAddress(dwIP);
  addrTo.sin_addr.S_un.S_addr=htonl(dwIP);
 }
 else
 {
  pHost=gethostbyname(strHostName);
  addrTo.sin_addr.S_un.S_addr=*((DWORD*)pHost->h_addr_list[0]);
 }
用DWORD取出的四个字节，正好是网络字节序表示的ULONG类型的地址。
这段代码在教学视频上在文本框中输入的是“sunxin”，我认为那是那台电脑的在网络上的主机名，而在我的电脑上只能输入“localhost”，或者我的主机名，否则程序异常中止。
如果要在接收数据框中显示主机名，
在LRESULT CChatDlg::OnSock(WPARAM wParam,LPARAM lParam)中添加如下代码：
 HOSTENT *pHost; pHost=gethostbyaddr((char*)&addrFrom.sin_addr.S_un.S_addr,4,AF_INET);
 str.Format("%s speak : %s",pHost->h_name,wsabuf.buf);
注意：指针之间可以任意转换，以上代码把一个ulong类型转换为char*，要先取地址再进行转换。
记住两个函数
The inet_ntoa function converts an (Ipv4) Internet network address into a string in Internet standard dotted format.
The inet_addr function converts a string containing an (Ipv4) Internet Protocol dotted address into a proper address for the IN_ADDR structure.


代码：// ChatDlg.cpp : implementation file

CChatDlg::~CChatDlg()
{
  if(m_socket)
    closesocket(m_socket);
}



BOOL CChatDlg::OnInitDialog()
{
  CDialog::OnInitDialog();

............
  InitSocket();
.............
}


BOOL CChatDlg::InitSocket()
{
  m_socket=WSASocket(AF_INET,SOCK_DGRAM,0,NULL,0,0);
  if(INVALID_SOCKET==m_socket)
  {
    MessageBox("创建套接字失败！");
    return FALSE;
  }
  SOCKADDR_IN addrSock;
  addrSock.sin_addr.S_un.S_addr=htonl(INADDR_ANY);
  addrSock.sin_family=AF_INET;
  addrSock.sin_port=htons(6000);
  if(SOCKET_ERROR==bind(m_socket,(SOCKADDR*)&addrSock,sizeof(SOCKADDR)))
  {
    MessageBox("绑定失败！");
    return FALSE;
  }
  if(SOCKET_ERROR==WSAAsyncSelect(m_socket,m_hWnd,UM_SOCK,FD_READ))//启用异步
  {
    MessageBox("注册网络读取事件失败！");
    return FALSE;
  }

  return TRUE;
}

void CChatDlg::OnSock(WPARAM wParam,LPARAM lParam)
{
  switch(LOWORD(lParam))
  {
  case FD_READ:
    WSABUF wsabuf;
    wsabuf.buf=new char[200];
    wsabuf.len=200;
    DWORD dwRead;
    DWORD dwFlag=0;
    SOCKADDR_IN addrFrom;
    int len=sizeof(SOCKADDR);
    CString str;
    CString strTemp;
    HOSTENT *pHost;
    if(SOCKET_ERROR==WSARecvFrom(m_socket,&wsabuf,1,&dwRead,&dwFlag,
            (SOCKADDR*)&addrFrom,&len,NULL,NULL))
    {
      MessageBox("接收数据失败！");
      return;
    }
    pHost=gethostbyaddr((char*)&addrFrom.sin_addr.S_un.S_addr,4,AF_INET);
    //str.Format("%s说 :%s",inet_ntoa(addrFrom.sin_addr),wsabuf.buf);
    str.Format("%s说 :%s",pHost->h_name,wsabuf.buf);
    str+="\r\n";
    GetDlgItemText(IDC_EDIT_RECV,strTemp);
    str+=strTemp;
    SetDlgItemText(IDC_EDIT_RECV,str);
    break;
  }
}

void CChatDlg::OnBtnSend() 
{
  // TODO: Add your control notification handler code here
  DWORD dwIP;
  CString strSend;
  WSABUF wsabuf;
  DWORD dwSend;
  int len;
  CString strHostName;
  SOCKADDR_IN addrTo;
  HOSTENT* pHost;
  if(GetDlgItemText(IDC_EDIT_HOSTNAME,strHostName),strHostName=="")
  {
    ((CIPAddressCtrl*)GetDlgItem(IDC_IPADDRESS1))->GetAddress(dwIP);
    addrTo.sin_addr.S_un.S_addr=htonl(dwIP);
  }
  else
  {
    pHost=gethostbyname(strHostName);
    addrTo.sin_addr.S_un.S_addr=*((DWORD*)pHost->h_addr_list[0]);
  }
  
  addrTo.sin_family=AF_INET;
  addrTo.sin_port=htons(6000);

  GetDlgItemText(IDC_EDIT_SEND,strSend);
  len=strSend.GetLength();
  wsabuf.buf=strSend.GetBuffer(len);
  wsabuf.len=len+1;

  SetDlgItemText(IDC_EDIT_SEND,"");

  if(SOCKET_ERROR==WSASendTo(m_socket,&wsabuf,1,&dwSend,0,
      (SOCKADDR*)&addrTo,sizeof(SOCKADDR),NULL,NULL))
  {
    MessageBox("发送数据失败！");
    return;
  }
  
}

IO - 同步，异步，阻塞，非阻塞 （亡羊补牢篇）
智障大师 的专栏
07-31 21万+
<br />当你发现自己最受欢迎的一篇blog其实大错特错时，这绝对不是一件让人愉悦的事。<br /> 《 IO - 同步，异步，阻塞，非阻塞 》是我在开始学习epoll和libevent的时候写的，主要的思路来自于文中的那篇link 。写完之后发现很多人都很喜欢，我还是非常开心的，也说明这个问题确实困扰了很多人。随着学习的深入，渐渐的感觉原来的理解有些偏差，但是还是没引起自己的重视，觉着都是一些小错误，无伤大雅。直到有位博友问了一个问题，我重新查阅了一些更权威的资料，才发现原来的文章中有很大的理论错
线程同步与异步套接字编程
QQ845264718
04-13 312
事件对象 事件对象也属于内核对象，它包含以下三个成员： 使用计数。 用于指明该事件是一个自动重置的事件还是一个人工重置的事件的布尔值。 （为了实现线程间的同步，不应该使用人工重置事件对象，而应该使用自动重置对象。） 指明该事件出于已通知状态还是未通知状态的布尔值。 事件对象有两种不同的类型：人工重置的事件对象和自动重置的事件对象。当人工重置的事件对象得到通知时，在等待该事件对象的所有线程均可变为可调度线程。当一个自动重置的事件对象得到通知时，在等待该事件对象的线程中只有一个线程变为可调度线程。 创建事件
线程同步和线程异步&同步套接字异步套接字
Sayesan的专栏
02-04 1338
线程同步和线程异步有什么区别？（重要基础知识） 打个比方，如果你在等一个人， 同步的时候，你会一直等到她来了之后才做其他事情，这个过程除了等待你啥都不会做， 异步的时候，你一边在等，可能一边玩游戏或者是看报纸什么的，一直到她到来，你的等待状态才会结束 在实现上，同步的过程会阻塞进程的所有其他操作，将同步转换为异步的最常见方法则是 将会阻塞进程的等待操作放入到一个新的进程中，同时为该等待操
第十六章 线程同步与异步套接字编程
qq_28337005的博客
05-24 271
事件对象也属于内核对象，包含一个使用计数，一个用于指明该事件是一个自动重置的事件还是一个人工重置的事件的布尔值，另一个用于指明该事件处于已通知状态还是未通知状态的布尔值。 有两种不同类型的事件对象。一种是人工重置的事件，另一种是自动重置的事件。 当人工重置的事件得到通知时，等待该事件的所有线程均变为可调度线程。当一个自动重置的事件得到通知时，等待该事件的线程中只有一个线程变为可调度线程。 我
C++ ASIO 实现异步套接字管理
热门推荐
CSDN
08-29 1万+
Boost ASIO（Asynchronous I/O）是一个用于异步I/O操作的C++库，该框架提供了一种方便的方式来处理网络通信、多线程编程和异步操作。特别适用于网络应用程序的开发，从基本的网络通信到复杂的异步操作，如远程控制程序、高并发服务器等都可以使用该框架。该框架的优势在于其允许处理多个并发连接，而不必创建一个线程来管理每个连接。最重要的是ASIO是一个跨平台库，可以运行在任何支持C++的平台下。
C++的线程同步与异步套接字编程源码.zip
04-03
在C++编程中，线程同步和异步套接字编程是两个重要的概念，尤其是在开发高性能、多用户并发的网络应用程序时。线程同步确保了数据的一致性和完整性，而异步套接字则提供了非阻塞的网络通信方式，提高了程序的执行...
线程同步与异步套接字VC++编程实例
03-15
在计算机编程领域，尤其是涉及到多线程和网络通信时，线程同步与异步套接字的概念至关重要。本文将深入探讨这两个主题，并结合VC++编程环境进行实例解析。 线程同步是多线程编程中的一个关键概念，它主要用于管理...
VC++ 线程同步与异步套接字编程实例
03-17
在Windows编程环境中，VC++（Visual C++）是开发者常用的一种工具，用于构建高效、可靠的桌面应用...通过学习这个实例，开发者可以更好地理解如何在实际项目中集成线程同步和异步套接字编程，提升程序的性能和可靠性。
线程同步与异步套接字编程解析
"Lesson16线程同步与异步套接字编程" 在多线程编程中，线程同步和异步套接字编程是确保程序正确性和性能的关键技术。线程同步是为了防止多个线程同时访问共享资源，避免数据竞争和死锁问题，而异步套接字编程则能...
C++ socket编程MFC CAsyncSocket
wingsing2010的专栏
07-26 3991
<br />一、TCP/IP 体系结构与特点<br />　　1、TCP/IP体系结构<br />　　TCP/IP协议实际上就是在物理网上的一组完整的网络协议。其中TCP是提供传输层服务，而IP则是提供网络层服务。TCP/IP包括以下协议：（结构如图1.1）<br /><br />(图1.1)<br />　　IP： 网间协议(Internet Protocol) 负责主机间数据的路由和网络上数据的存储。同时为ICMP，TCP，　　　UDP提供分组发送服务。用户进程通常不需要涉及这一层。<br /><br />
套接字 同步 异步
小憩一下
05-09 3808
多个TCP连接或多个应用程序进程可能需要通过同一个 TCP协议端口传输数据。为了区别不同的应用程序进程和连接，许多计算机操作系统为应用程序与TCP／IP协议交互提供了称为套接字(Socket)的接口。 分类 　　常用的TCP/IP协议的3种套接字类型如下所示。 　　流套接字（SOCK_STREAM）： 　　流套接字用于提供面向连接、可靠的数据传输服务。该服务将保
深入了解异步套接字
YeppC的专栏
02-23 1043
深入了解异步套接字 CAsyncSocket异步套接字是MFC封装的SOCKET的类。只有在三种条件下，才会发出FD_WRITE通知：1、使用connect或WSAConnect,一个套接字首次建立了连接；2、使用accept或WSAAccept,套接字被接受以后；3、若send、WSASend、sendto或WSASendTo操作失败，返回了WSAEWOULDBLOC
(源码)基于JavaWeb的饮品销售管理系统.zip
最新发布
11-15
# 基于Java Web的饮品销售管理系统 ## 项目简介 本项目是一个基于Java Web的饮品销售管理系统，主要用于学校实训课程的作业。系统涵盖了从用户管理、商品管理、订单管理到购物车管理的全套功能，旨在提供一个完整的在线饮品销售解决方案。 ## 项目的主要特性和功能 ### 用户管理 用户注册与登录支持用户注册新账号和登录系统。 用户信息管理包括用户信息的查询、修改和删除。 用户类型管理区分不同类型的用户（如管理员、普通用户）。 ### 商品管理 商品CRUD操作支持商品的添加、修改、删除和查询。 商品分类管理支持多级商品分类的查询和管理。 商品分页查询支持按页查询商品信息，提高查询效率。 ### 订单管理 订单CRUD操作支持订单的创建、修改、删除和查询。 订单明细管理支持订单明细的添加和管理。 订单状态管理支持订单状态的更新和查询。 ### 购物车管理
BitmapFunc.rar
11-15
BitmapFunc
c++课程设计-产品入库管理操作系统.zip
11-15
c++课程设计-产品入库管理操作系统
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值