（四）基于BOOST ASIO实现的异步TCP客户端与服务端

最新推荐文章于 2024-06-13 02:14:54 发布
最新推荐文章于 2024-06-13 02:14:54 发布
阅读量1k 收藏 4
点赞数
分类专栏： 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xushuilong/article/details/106474203
版权

（四）基于BOOST ASIO实现的异步TCP客户端与服务端

代码

//asio_socket.h
#pragma once
#include <queue>
#include <mutex>
#include <string>
#include <vector>
#include <atomic>
#include <map>
#include <unordered_map>
#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <assert.h>
#include <condition_variable>
#include <iostream>
#include "glog/init_glog.h"

typedef boost::asio::io_service								io_service_type;
typedef boost::shared_ptr<io_service_type>					io_service_ptr_type;
typedef boost::asio::ip::tcp::resolver						tcp_resolver_type;
typedef boost::asio::ip::udp::resolver						udp_resolver_type;
typedef boost::asio::ip::tcp::socket						tcp_socket_type;
typedef boost::asio::ip::udp::socket						udp_socket_type;
typedef boost::shared_ptr<tcp_socket_type>					tcp_socket_ptr_type;
typedef boost::shared_ptr<udp_socket_type>					udp_socket_ptr_type;
typedef boost::asio::ip::tcp::endpoint						tcp_endpoint_type;
typedef boost::asio::ip::udp::endpoint						udp_endpoint_type;
typedef boost::asio::ip::address							address_type;
typedef boost::asio::ip::address_v4							address_v4_type;
typedef boost::asio::ip::address_v6							address_v6_type;
typedef boost::asio::io_service::work						work_type;
typedef boost::shared_ptr<work_type>						work_ptr_type;
typedef boost::asio::ip::tcp::acceptor						tcp_acceptor_type;
typedef boost::shared_ptr<tcp_acceptor_type>				tcp_acceptor_ptr_type;
typedef boost::asio::deadline_timer							dtimer_type;
typedef boost::system::error_code							error_code_type;
typedef std::vector<char>									buffer_type;

#define TCP_V4												boost::asio::ip::tcp::v4()
#define TCP_V6												boost::asio::ip::tcp::v6()
#define UDP_V4												boost::asio::ip::udp::v4()
#define UDP_V6												boost::asio::ip::udp::v6()
#define TCP_V4_PROTOCOL										boost::asio::ip::tcp::v4().protocol()
#define TCP_V6_PROTOCOL										boost::asio::ip::tcp::v6().protocol()
#define UDP_V4_PROTOCOL										boost::asio::ip::udp::v4().protocol()
#define UDP_V6_PROTOCOL										boost::asio::ip::udp::v6().protocol()

#define BOOST_SLEEP_S(x)									(boost::this_thread::sleep(boost::posix_time::seconds(x)))
#define BOOST_SLEEP_MS(x)									(boost::this_thread::sleep(boost::posix_time::milliseconds(x)))


const size_t tcp_max_readbuf_size = 2000;
const size_t tcp_max_writebuf_size = 2000;
const size_t udp_max_sendbuf_size = 2000;
const size_t udp_max_recvbuf_size = 2000;
const int tcp_max_readbuf_raw_size = 65536;
const int tcp_max_msg_length = 65536;
const int udp_max_msg_length = 65536;
const int tcp_max_connected_server_num = 2;// 64;//服务端最大连接数
const int tcp_server_read_timeout = 15;//服务端连接读取超时时间，若长时间没有心跳将断开连接
const int INFIT_TIME = 0x7FFFFFFF;

//asio_async_tcp_client.hpp
#pragma once
#include "asio_socket.h"
using std::string;
using std::vector;

class CAsyncClient
{
private:
	io_service_type m_ios;
	work_type m_work;
	string m_id;
	std::atomic<bool> m_stopped;
	tcp_endpoint_type m_ep;
	tcp_socket_type m_sock;

	std::mutex mut_readbuf;
	std::mutex mut_write_sock;
	std::queue<string> m_readbuf;
	std::condition_variable cv_readbuf_notempty;

	buffer_type m_readbuf_raw;//TCP原始字节流BUF，待拆包
public:
	CAsyncClient(const string & ip, int port, int id)
		: m_id("C" + std::to_string(id) + "> ")
		, m_stopped(false)
		, m_ep(address_v4_type::from_string(ip), port)
		, m_sock(m_ios)
		, m_work(m_ios)
	{
		connect_socket();
		boost::thread th_read([this]()->void{ m_ios.run(); });
		LOG_INFO_GLOG << m_id << "client connected "<<ip<<":"<<port;
	}

	~CAsyncClient()
	{
		m_work.~work();
		cv_readbuf_notempty.notify_all();
		close_socket();
		while (!m_ios.stopped())
		{
			BOOST_SLEEP_MS(500);
		}
		LOG_INFO_GLOG << m_id << "stop client";
	}

	inline tcp_socket_type & socket(){ return m_sock; }

	inline const string local_ip(){ return m_sock.local_endpoint().address().to_string(); }

	inline const string remote_ip(){ return m_sock.remote_endpoint().address().to_string(); }

	inline const bool is_stopped(){ return !!m_stopped; }
	
	void push_writebuf(const string & msg, bool b_log = true)
	{
		start_async_write(msg,b_log);
	}

	bool pop_readbuf(string & msg)
	{
		msg.clear();
		std::unique_lock<std::mutex> lk(mut_readbuf);
		cv_readbuf_notempty.wait(lk, [this](){return (!m_readbuf.empty() || m_stopped); });
		if (m_stopped)
		{
			LOG_WARN_GLOG << m_id << "exit pop_readbuf as socket stopped";
			return false;
		}
		msg = m_readbuf.front();
		m_readbuf.pop();
		return true;
	}

private:
	void close_socket()
	{
		error_code_type err_asio;
		m_sock.close(err_asio);
		m_stopped = true;
		cv_readbuf_notempty.notify_all();
		LOG_INFO_GLOG << m_id << "closed";
	}

	void connect_socket()
	{
		error_code_type err_asio;
		do
		{
			m_sock.connect(m_ep, err_asio);//阻塞
			BOOST_SLEEP_MS(20);
		} while (err_asio && err_asio != boost::asio::error::already_connected);
		m_stopped = false;
		m_readbuf_raw.assign(tcp_max_msg_length, 0);
		start_async_read();
	}

	void start_async_read(int last_ready_size=0)
	{
		//m_readbuf_raw中已存有一部分不完整的报文内容，大小raw_ready_size
		if (m_stopped)
		{
			return;
		}

		m_sock.async_read_some(boost::asio::buffer(&m_readbuf_raw[last_ready_size], 
			tcp_max_msg_length - last_ready_size),
			boost::bind(&CAsyncClient::handle_async_read, this,
			boost::asio::placeholders::error,
			boost::asio::placeholders::bytes_transferred,
			last_ready_size));
	}

	void handle_async_read(const error_code_type & err, const size_t size, int last_ready_size)
	{
		if (m_stopped)
		{
			return;
		}
		if (err)
		{
			LOG_WARN_GLOG << m_id << "read failed:" << err.message();
			close_socket();
			connect_socket();
			return;
		}
		/以下对报文进行拆包///
		int ready_size = last_ready_size + size;//未拆包的字节数
		int split_size = 0;//已拆包的字节数
		while (ready_size>0)
		{
			if (ready_size<4)
			{
				std::copy(m_readbuf_raw.begin() + split_size, m_readbuf_raw.end(), m_readbuf_raw.begin());
				std::fill(m_readbuf_raw.begin() + (m_readbuf_raw.size() - split_size), m_readbuf_raw.end(), 0);
				break;//不足一个头部的大小
			}
			int cur_msg_length = ntohl(*(int *)(&m_readbuf_raw[split_size]));
			if (cur_msg_length <= 0 || cur_msg_length > tcp_max_msg_length-4)//最大接收报文长度限制
			{
				LOG_WARN_GLOG << m_id << "msg length error,length=" << cur_msg_length;
				close_socket();
				connect_socket();
				return;
			}
			if (ready_size<4 + cur_msg_length)
			{
				std::copy(m_readbuf_raw.begin() + split_size, m_readbuf_raw.end(), m_readbuf_raw.begin());
				std::fill(m_readbuf_raw.begin() + (m_readbuf_raw.size() - split_size), m_readbuf_raw.end(), 0);
				break;//不足一个完整报文大小
			}
			split_size += 4;//拆头
			ready_size -= 4;
			string cur_msg((char *)(&m_readbuf_raw[split_size]), cur_msg_length);
			LOG_INFO_GLOG << m_id << "recv:" << cur_msg.substr(0, 2048);
			push_readbuf(std::move(cur_msg));
			split_size += cur_msg_length;//拆MSG
			ready_size -= cur_msg_length;
		}//while
		start_async_read(ready_size);
	}

	void start_async_write(const string & msg, bool b_log)
	{
		if (m_stopped)
		{
			return;
		}
		int length = (int)msg.size();
		length = htonl(length);
		string tmp_msg((char *)&length, 4);
		tmp_msg.append(msg);
		LOG_IF_INFO_GLOG(b_log) << m_id << "send: " << msg;
		std::unique_lock<std::mutex> lk(mut_write_sock);
		boost::asio::async_write(m_sock, boost::asio::buffer(tmp_msg.data(), tmp_msg.size()),
			boost::bind(&CAsyncClient::handle_async_write, this, boost::placeholders::_1));
	}

	void handle_async_write(const error_code_type & err)
	{
		if (m_stopped)
		{
			return;
		}
		if (err)
		{
			if (err == boost::asio::error::operation_aborted)
			{
				if (m_sock.is_open())
				{
					LOG_WARN_GLOG << m_id << "send failed:" << err.message();
				}
				else
				{
					LOG_WARN_GLOG << m_id << "send failed:" << err.message();
					connect_socket();
				}
			}
			else
			{
				LOG_WARN_GLOG << m_id << "send failed:" << err.message();
				close_socket();
				connect_socket();
			}
		}
	}

	void push_readbuf(string && msg)
	{
		{
			std::unique_lock<std::mutex> lk(mut_readbuf);
			if (m_readbuf.size() >= tcp_max_readbuf_size)
			{
				m_readbuf.pop();
				LOG_EVERY_WARN_GLOG(20) << m_id << "readbuf overflow";
			}
			m_readbuf.emplace(std::move(msg));
		}
		cv_readbuf_notempty.notify_one();
	}
};

typedef boost::shared_ptr<CAsyncClient>				pAsyncClientType;

//asio_async_tcp_server.hpp
#pragma once
#include "asio_socket.h"
#include "asio_timer.hpp"
using std::string;
using std::vector;

class CAsyncServer
{
	friend class CAsyncAcceptor;
	typedef std::pair<string, int>		TMSG;//消息和超时时间
private:
	string m_id;
	std::atomic<bool> m_stopped;
	tcp_endpoint_type m_ep;
	tcp_socket_type m_sock;
	std::mutex mut_readbuf;
	std::mutex mut_write_sock;
	std::queue<string> m_readbuf;
	std::condition_variable cv_readbuf_notempty;

 	buffer_type m_readbuf_raw;//TCP原始字节流BUF，待拆包
public:
	CAsyncServer(io_service_type & ios, int id)
		: m_id("S" + std::to_string(id) + "> ")
		, m_stopped(false)
		, m_ep(address_v4_type::from_string("0.0.0.0"), 0)
		, m_sock(ios)
	{
	}

	~CAsyncServer()
	{		
		cv_readbuf_notempty.notify_all();
		close_socket();
		LOG_INFO_GLOG << m_id << "stop server";
	}

	inline tcp_socket_type & socket(){ return m_sock; }

	inline const string local_ip(){ 
		return m_sock.local_endpoint().address().to_string(); }

	inline const string remote_ip(){ 
		return m_sock.remote_endpoint().address().to_string(); }

	inline const bool is_stopped(){ return !!m_stopped; }

	void push_writebuf(const string & msg, bool b_log = true)
	{
		start_async_write(msg, b_log);
	}

	bool pop_readbuf(string & msg)
	{
		msg.clear();
		std::unique_lock<std::mutex> lk(mut_readbuf);
		cv_readbuf_notempty.wait_for(lk, std::chrono::seconds(tcp_server_read_timeout), 
			[this](){return (!m_readbuf.empty() || m_stopped); });
		if (m_stopped)
		{
			LOG_WARN_GLOG << m_id << "exit pop_readbuf as socket stopped";
			return false;
		}
		if (m_readbuf.empty())
		{
			close_socket();
			LOG_WARN_GLOG << m_id << "read timeout,close_socket";//心跳超时
			return false;
		}
		msg = m_readbuf.front();
		m_readbuf.pop();
		return true;
	}

private:
	void close_socket()
	{
		try
		{
			if (!m_stopped)
			{
				error_code_type err_asio;
				m_sock.close(err_asio);
				m_stopped = true;
				cv_readbuf_notempty.notify_all();
				LOG_INFO_GLOG << m_id << "closed";
			}
		}
		catch (std::exception &err)
		{
			LOG_INFO_GLOG << m_id << "close_socket crash:" << err.what();
		}
		catch (...)
		{
			LOG_INFO_GLOG << m_id << "close_socket crash:unknown error";
		}
	}

	void start_async_read(int last_ready_size = 0)
	{
		if (m_stopped)
		{
			return;
		}
		if (last_ready_size<=0)
		{
			m_readbuf_raw.assign(tcp_max_msg_length, 0);
		}
		m_sock.async_read_some(boost::asio::buffer(&m_readbuf_raw[last_ready_size], 
			tcp_max_msg_length - last_ready_size),
			boost::bind(&CAsyncServer::handle_async_read,this, 
			boost::asio::placeholders::error,
			boost::asio::placeholders::bytes_transferred,
			last_ready_size));
	}

	void handle_async_read(const error_code_type & err_, const size_t size_, int last_ready_size)
	{
		if (m_stopped)
		{
			return;
		}
		if (err_)
		{
			LOG_WARN_GLOG << m_id << "read failed:" << err.message();
			close_socket();
			return;
		}
		/以下对报文进行拆包///
		int ready_size = last_ready_size + size;//未拆包的字节数
		int split_size = 0;//已拆包的字节数
		while (ready_size>0)
		{
			if (ready_size<4)
			{
				std::copy(m_readbuf_raw.begin() + split_size, m_readbuf_raw.end(), m_readbuf_raw.begin());
				std::fill(m_readbuf_raw.begin() + (m_readbuf_raw.size() - split_size), m_readbuf_raw.end(), 0);
				break;//不足一个头部的大小
			}
			int cur_msg_length = ntohl(*(int *)(&m_readbuf_raw[split_size]));
			if (cur_msg_length <= 0 || cur_msg_length > tcp_max_msg_length - 4)//最大接收报文长度限制
			{
				LOG_WARN_GLOG << m_id << "msg length error,length=" << cur_msg_length;
				close_socket();
				return;
			}
			if (ready_size < 4 + cur_msg_length)
			{
				std::copy(m_readbuf_raw.begin() + split_size, m_readbuf_raw.end(), m_readbuf_raw.begin());
				std::fill(m_readbuf_raw.begin() + (m_readbuf_raw.size() - split_size), m_readbuf_raw.end(), 0);
				break;//不足一个完整报文大小
			}
			split_size += 4;//拆头
			ready_size -= 4;
			string cur_msg((char *)(&m_readbuf_raw[split_size]), cur_msg_length);
			LOG_INFO_GLOG << m_id << "recv:" << cur_msg.substr(0, 2048);
			push_readbuf(std::move(cur_msg));
			split_size += cur_msg_length;//拆MSG
			ready_size -= cur_msg_length;
		}
		start_async_read(ready_size);
	}

	void start_async_write(const string & msg, bool b_log)
	{
		if (m_stopped)
		{
			return;
		}
		int length = (int)msg.size();
		length = htonl(length);
		string tmp_msg((char *)&length, 4);
		tmp_msg.append(msg);
		LOG_IF_INFO_GLOG(b_log) << m_id << "send: " << msg;
		std::unique_lock<std::mutex> lk(mut_write_sock);
		boost::asio::async_write(m_sock, boost::asio::buffer(tmp_msg.data(), tmp_msg.size()),
			boost::bind(&CAsyncServer::handle_async_write, this, boost::placeholders::_1));
	}

	void handle_async_write(const error_code_type & err)
	{
		if (m_stopped)
		{
			return;
		}
		if (err)
		{
			close_socket();
			LOG_WARN_GLOG << m_id << "send failed:" << err.message();
		}
	}

	void push_readbuf(string && msg)
	{
		{
			std::unique_lock<std::mutex> lk(mut_readbuf);
			if (m_readbuf.size() >= tcp_max_readbuf_size)
			{
				m_readbuf.pop();
				LOG_EVERY_WARN_GLOG(20) << m_id << "readbuf overflow";
			}
			m_readbuf.emplace(std::move(msg));
		}
		cv_readbuf_notempty.notify_one();
	}
};

typedef boost::shared_ptr<CAsyncServer>				pAsyncServerType;

class CAsyncAcceptor
{
private:
	io_service_type m_ios; //acceptor的监听IOS
	tcp_acceptor_type m_acceptor;
	std::list<pAsyncServerType> m_servers;
	std::function<void(pAsyncServerType &)> m_handle_func;
	work_ptr_type m_pwork;
	boost::thread_group m_thgroup_srv;
	std::vector<std::pair<io_service_ptr_type, work_ptr_type>> m_vec_ios;//供服务端连接套接字使用
	std::atomic<bool> m_stop_listen;

	TimerAsio timer_clear_server_list;
public:
	CAsyncAcceptor(int  port, int ios_num)
		:m_acceptor(m_ios, tcp_endpoint_type(address_v4_type::from_string("0.0.0.0"), port))
		, m_stop_listen(false)
		, timer_clear_server_list (m_ios , 10000, 10000)
	{
		m_servers.clear();
		if (ios_num < 0){ ios_num = 0 };

		//创建IO_SERVICE线程，作为pAsyncServerType的IO工作线程，用于读写TCP流
		for (int i = 0; i < ios_num; ++i)
		{
			io_service_ptr_type pios = boost::make_shared<io_service_type>();
			work_ptr_type pwork = boost::make_shared<work_type>(*pios);
			m_vec_ios.emplace_back(pios, pwork);
			m_thgroup_srv.create_thread(boost::bind(&io_service_type::run, &(*pios)));
		}

		//创建IO_SERVICE线程，作为CAsyncAcceptor的IO工作线程，用于监听TCP连接
		m_pwork = boost::make_shared<work_type>(m_ios);
		boost::thread th1(boost::bind(&io_service_type::run, &m_ios));

		//启动定时器，用于清理过期的server连接
		timer_clear_server_list.SetCallBack(std::bind(&CAsyncAcceptor::ClearServerList, this));
		timer_clear_server_list.Start();

		LOG_INFO_GLOG << "server start listen on port=" << port;
	}

	~CAsyncAcceptor()
	{
		timer_clear_server_list.Stop();
		m_pwork.reset();
		m_ios.stop();
		for (int i = 0; i < m_vec_ios.size(); ++i)
		{
			m_vec_ios[i].second.reset();
			m_vec_ios[i].first->stop();
		}
		if (!m_vec_ios.empty())
		{
			m_thgroup_srv.interrupt_all();
			m_thgroup_srv.join_all();
		}
	}

	void ClearServerList()
	{
		int size_before_remove = m_servers.size();
		m_servers.remove_if([](pAsyncServerType & e){return e->is_stopped(); });
		int size_after_remove = m_servers.size();
		LOG_IF_INFO_GLOG(size_before_remove != size_after_remove) << "size_before_remove="
			<< size_before_remove << ";size_after_remove=" << size_after_remove;
		if (m_stop_listen == true && size_after_remove < tcp_max_connected_server_num)
		{
			StartAsyncAccept();
			m_stop_listen = false;
			LOG_INFO_GLOG << "server restart listen";
		}
	}

	void SetAcceptHandle(std::function<void(pAsyncServerType &)> handle)
	{
		m_handle_func = handle;
	}

	void StartAsyncAccept()
	{
		static int id = 0;
		LOG_IF_FATAL_GLOG(!m_handle_func) << "accept handle is null";

		if (m_servers.size() >= tcp_max_connected_server_num && m_stop_listen == false)
		{
			LOG_INFO_GLOG << "server connection overflow ,stop listen";
			m_stop_listen = true;
			return;
		}
		pAsyncServerType psrv;
		if (m_vec_ios.empty())
		{
			psrv = boost::make_shared<CAsyncServer>(m_ios, id);
		}
		else
		{
			int size_ios = m_vec_ios.size();
			psrv = boost::make_shared<CAsyncServer>(*m_vec_ios[id%size_ios].first, id);
		}
		id++;
		m_acceptor.async_accept(psrv->socket(), [this, psrv](const error_code_type & err_)->void{
			if (!err_)
			{
				m_servers.push_back(psrv);//服务端连接对象加入服务端管理链表
				psrv->start_async_read();//server read buf--生产
				boost::thread th(boost::bind(m_handle_func, psrv));//server read buf--消费
			}
			else
			{
				LOG_INFO_GLOG << "accept error:" << err_.message();
			}
			StartAsyncAccept();
		});
	}
};

使用说明

xushuilong
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C++ Boost】一个最基本的异步boost async tcp 服务/客户端代码的深刻解析，一文解决所有接口的用法以及一些容易出错的点
赖东东_的博客
03-15 2836
Boost async tcp一、平台的选择以及基本构建方法1.官网链接2.平台选择3.Boost库下载4.构建方法二、服务端 代码片段讲解+接口解析+易错点解析1.main函数代码（boost_server.cpp）2. 任务类 class tcpserver 代码（boost_server.h）（1）构造函数及启动函数start（2） 接受函数accept()的解析以及shared_from_this的核心问题（3） async_read()与async_read_some()注意事项（4） async
基于boost库的tcp协议通信
04-24
本资源是基于boost库的tcp协议通讯实例，目前已经在实际项目中使用
boost-Asio 基础学习2 --socket 服务端和客户端简单通讯
最新发布
weixin_48158333的博客
06-13 811
已经写了两期文章了!这是第三期 现在也到使用asio库实现一些基础的小功能了🤓服务端和客户端简单的发送消息。
Boost Asio异步TCP网络编程实例
guotianqing的博客
03-11 2705
简介 本文主要描述TCP协议的实现，其他协议类似。 关于Boost Asio库是什么，请参考Boost Asio快速入门。这篇文章概述了Asio库的重点。 关于Boost Asio中提供的函数及使用，请参考Boost Asio 网络编程理论基础。该文可以快速预览，待到使用时再回来查询。另外，该文关于异步编程的关键注意点也有阐述。 本文关注于异步编程的实现（关于同步和异步的异同，请参考上文）。异步...
boost asio实现的TCP客户端(同时支持ssl)
hacker_lpy的博客
02-15 5149
因为要开发TCP客户端用于网络通信，用c++来写，要实现跨平台在window和linux都能用的话，自己去封装原始的套接字操作，要兼容linux和window两个平台，有点困难，工作量也不小，于是用了现有的别人封装好的库，boost的asio来封装一个TCP客户端。 boost 的asio是一个优秀的全异步跨平台的网络通信库，不过源码都是用模板来写的，看起来比较吃力。因为通信也有需要用到SSL的情况，所以设计的TcpClient兼容普通的套接字通信和ssl通信，可以作为初学者的借鉴，分为4个文件，代码如下：
boost.asio异步并发Tcp服务器
Erick Lv的笔记
02-19 1916
简介 reactor模式 proactor模式 异步并发模型说明 代码示例 基于boost 1.70和C++14 CMakeLists.txt # cmake_minimum_required(VERSION <specify CMake version here>) project(boost_asio) set(CMAKE_CXX_STANDARD 14) set(CMAKE_C...
深入Boost.asio的异步Tcp通信的server、client，可用来当程序骨架。
zhengzhongjie的专栏
03-20 6010
程序功能： 客户端用名字登录服务端 连接由客户端驱动，客户端请求，服务端应答 所有的请求和应答都以\n结尾 当客户端在5秒内没有发ping请求，服务端就关闭连接 客户端可以请求所有已经建立连接的用户列表 客户端可以发ping请求，服务端应答 ping ok或者ping client_list_chaned，客户端收到 ping client_list_chaned后会重新请求用户列表 让程序变得有意
boost库异步完整客户端和服务端程序
08-12
这个"boost库异步完整客户端和服务端程序"是一个在Visual Studio 2008环境下编写的实例，展示了如何使用Boost.Asio进行异步TCP通信。 异步编程是一种处理I/O操作的方法，其中程序不会阻塞等待结果，而是继续执行...
tc.zip_TCP 服务端_TCP客户端异步_tcp 异步
09-14
5. **异步编程库**：许多编程语言提供了异步编程库，如C++的Boost.Asio、Node.js的EventEmitter、Python的asyncio等，这些库为开发者提供了方便的接口来编写异步TCP应用。 根据提供的文件名`test.cpp`和`test2.cpp`...
boost asio 服务器和客户端 TCP
06-14
在TCP（传输控制协议）环境下，Boost.Asio可以用来构建服务器和客户端应用程序。让我们深入了解一下如何使用Boost.Asio来创建这些组件。 首先，我们要理解TCP的基本概念。TCP是一种面向连接的、可靠的传输层协议，...
TCP 客户端 服务端 网络编程
10-26
- **并发处理**：服务端可能需要同时处理多个客户端的连接，因此需要实现并发模型，如多线程、多进程或异步I/O。 - **流量控制**：TCP协议内置了流量控制机制，防止发送方过快导致接收方处理不过来。 - **拥塞控制**...
asio-tcp-dll，服务端，封装成dll
04-26
标题中的"asio-tcp-dll，服务端，封装成dll"指出这是一个使用`asio`库实现的TCP服务器，并且已经封装成了动态链接库（DLL）的形式。DLL是一种可执行文件格式，它允许多个程序共享同一段代码和资源，从而节省内存并...
基于boost::asio的异步tcp通信框架
05-07 2957
最近在做ROS与树莓派进行通信时，发现boost:asio库还蛮强大的，就试着用asio写了一个简单的使用tcp传输轨迹数据到树莓派，让树莓派控制步进电机旋转的代码。其实也就是将asio的功能封装成了两个类而已。asio_server类运行于树莓派上作为服务器，asio_client运行于PC上作为客户端。刚开始写的代码仅仅是客户端发送，服务器端接收这么简单。但后来一想，树莓派不是还要返回数据给R...
【C++】BOOST ASIO 异步客户端代码分析
artzers的专栏
03-26 911
参考资料：《Boost Asio C++网络编程》第四章 这里将对asio库编写的异步客户端进行解读。异步客户端比同步客户端更复杂。同步客户端相对简单，实用性不大，一般用于业务测试，基本就是一条线的逻辑代码。 环境设置 asio客户端项目仅需包含boost.asio头文件，无需导入lib文件： #include <boost/thread.hpp> #include <boost...
使用boost实现tcp server/client
seaeress的博客
09-27 2265
使用boost实现简单的tcp 客户端服务器，附源码
boost::asio教程(二) ：异步tcp
琅嬛福地
10-30 1073
  如何理解同步，异步呢？用400米接力赛来说，前一个队员到达时，下一个队员才能继续往前跑，这种跑步方式可以理解为同步，一步步的进行；而百米赛跑，8个赛道，所有人同时跑，这种类似于异步。异步不需要等待，同步会阻塞主线程。   本专栏上一篇介绍了boost tcp server与client的实现方式，本篇介绍boost asio异步tcp的实现。 先回忆boost::asio同步的实现方式   在学习boost::asio异步tcp之前，先看看上一篇关于同步tcp server与client的实现方式。 a
Boost.Asio基础（五） 异步编程初探
shangguanwaner的专栏
03-19 1718
异步编程       本节深入讨论异步编程将遇到的若干问题。建议多次阅读，以便吃透这一节的内容，这一节是对整个boost.asio来说是非常重要的。为什么需要异步       如前所述，通常同步编程要比异步编程更简单。。。。
VS2022通过C++网络库Boost.asio搭建一个简单TCP异步服务器和客户端
LorraineWen的博客
05-23 1554
上一篇博客我们介绍了通过Boost.asio搭建一个TCP同步服务器和客户端，这次我们再通过asio搭建一个异步通信的服务器和客户端系统，由于这是一个简单异步服务器，所以我们的异步特指异步服务器而不是异步客户端，同步服务器在处理一个请求时会阻塞其他请求，而异步服务器可以同时处理多个请求，不会阻塞其他请求的处理，客户端一般是不会处理其他客户端请求的，所以客户端仍旧使用同步模式。（本次博客使用的Boost库版本是1.84.0)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值