*_at方法
这些方法在一个流上面做随机存取操作。你来指定read和write操作从什么地方開始(offset):
async_read_at(stream, offset, buffer [, completion], handler):这种方法在一个指定的流上从offset处開始运行一个异步的read操作,当操作结束时,他会调用handler。

handler的格式为:void handler(const boost::system::error_code&  err,
size_t bytes);。buffer能够是普通的wrapper()包装或者streambuf方法。假设你指定一个completion方法。它会在每次read操作成功之后调用,然后告诉Boost.Asio async_read_at操作已经完毕(假设没有,则继续读取)。它的格式为:size_t
 completion(const boost::system::error_code& err, size_t bytes);。

当completion方法返回0时。我们觉得read操作完毕了;假设返回一个非零值。

它代表了下一次调用流的async_read_some_at方法的最大读取字节数。

async_write_at(stream, offset, buffer [, completion], handler):这种方法运行一个异步的write操作。參数的意义和async_read_at是一样的
read_at(stream, offset, buffer [, completion]):这种方法在一个运行的流上,指定的offset处開始read。

參数的意义和async_read_at是一样的

write_at(stream, offset, buffer [, completion]):这种方法在一个运行的流上,指定的offset处開始write。參数的意义和async_read_at是一样的
这些方法不支持套接字。它们用来处理流的随机訪问。也就是说,流是能够随机訪问的。套接字显然不是这样(套接字是不可返回的)
以下这个样例告诉你怎么从一个文件偏移为256的位置读取128个字节:
io_service service;
int main(int argc, char* argv[]) {
HANDLE file = ::CreateFile("readme.txt", GENERIC_READ, 0, 0,
OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
0);
windows::random_access_handle h(service, file);
streambuf buf;
read_at(h, 256, buf, transfer_exactly(128));
std::istream in(&buf);
std::string line;
std::getline(in, line);
std::cout << "first line: " << line << std::endl;
}
异步编程
这个部分对你在进行异步编程时可能碰到的一些问题进行了深入的探究。再读了一遍之后。我建议你在接下来学习这本书的时候,常常回过头来再读读,从而增强你对这部分的理解。

异步的需求
就像我之前所说的,同步编程比异步编程简单非常多。

这是由于,线性的思考是非常easy的(调用A,调用A结束,调用B,调用B结束。然后继续,这是以事件处理的方式来思考)。

在后面的你会碰到这样的情况,比方:五件事情,你不知道它们运行的顺序。也不知道他们是否会运行!

虽然异步编程更难。可是你会更倾向于它。比方:写一个须要处理非常多并发訪问的服务端。

并发訪问越多,异步编程就比同步编程越简单。

如果:你有一个软件处理1000个并发訪问。每一个信息都从client发给服务端。然后再返回给client,以‘\n’结尾。
同步方式的代码,1个线程:
using namespace boost::asio;
struct client {
ip::tcp::socket sock;
char buff[1024]; // each msg is at maximum this size
int already_read; // how much have we already read?

};
std::vector<client> clients;
void handle_clients() {
while ( true)
for ( int i = 0; i < clients.size(); ++i)
if ( clients[i].sock.available() ) on_read(clients[i]);
}
void on_read(client & c) {
int to_read = std::min( 1024 - c.already_read, c.sock.
available());
c.sock.read_some( buffer(c.buff + c.already_read, to_read));
c.already_read += to_read;
if ( std::find(c.buff, c.buff + c.already_read, '\n') < c.buff +
c.already_read) {
int pos = std::find(c.buff, c.buff + c.already_read, '\n') -
c.buff;
std::string msg(c.buff, c.buff + pos);
std::copy(c.buff + pos, c.buff + 1024, c.buff);
c.already_read -= pos;
on_read_msg(c, msg);
}
}
void on_read_msg(client & c, const std::string & msg) {
// analyze message, and write back
if ( msg == "request_login")
c.sock.write( "request_ok\n");
else if ...
}
有一件事情是你在不论什么服务端(和不论什么基于网络的软件)都须要避免的,就是代码不再响应。在我们样例里,我们须要handle_ clients()方法尽可能少的堵塞。假设放在在不论什么点上堵塞,不论什么进来的信息都须要等待方法解除堵塞然后再去处理它们。

为了保持响应,我们仅仅在一个套接字有数据的时候我们才读,也就是说。if ( clients[i].sock.available() ) on_read(clients[i])。在on_read时,我们仅仅读可用的。调用read_until(c.sock, buffer(...),  '\n')会是一个很糟糕的选择,由于直到我们从一个选定的客户端读取了完整的消息之前,它都会是堵塞的(我们永远不知道它什么时候会读取到完整的消息)
这里的瓶颈就是on_read_msg()方法;当它运行时。所以进来的消息都在等待。一个良好的on_read_msg()方法实现会保证这样的情况基本不会发生。可是它还是会发生(有些时候向一个套接字写入数据时,当他的缓冲区满了,它会被堵塞)
同步方式的代码,10个线程
using namespace boost::asio;
struct client {
// ... same as before
bool set_reading() {
boost::mutex::scoped_lock lk(cs_);
if ( is_reading_) return false; // already reading
else { is_reading_ = true; return true; }
}
void unset_reading() {
boost::mutex::scoped_lock lk(cs_);
is_reading_ = false;
}
private:
boost::mutex cs_;
bool is_reading_;
};
std::vector<client> clients;
void handle_clients() {
for ( int i = 0; i < 10; ++i)
boost::thread( handle_clients_thread);
}
void handle_clients_thread() {
while ( true)
for ( int i = 0; i < clients.size(); ++i)
if ( clients[i].sock.available() )
if ( clients[i].set_reading()) {
on_read(clients[i]);
clients[i].unset_reading();
}
}
void on_read(client & c) {
// same as before
}
void on_read_msg(client & c, const std::string & msg) {
// same as before
}
为了使用多线程,我们须要对它进行同步,这就是set_reading()和set_unreading()所做的。set_reading()方法很重要,你想要一步实现“測试读取然后标记为读取中”。假设你有两步(“測试读取”和“标记为读取中”)。你可能会有两个线程同一时候为一个client做測试读取操作,然后你会有两个线程同一时候为一个client调用on_read。结果就是数据冲突甚至可能导致软件崩溃。

你会发现代码变得极其复杂。
同步编程有第三个选择,就是为每一个连接开辟一个线程。

当时当并发的线程添加时。这就变成了一个最不能出现的情况。

然后,让我们来看异步编程。

我们不断的异步读取。当一个client请求某些东西时,on_read被调用,然后回应。然后等待下一个请求(然后開始另外一个异步的read操作)。

异步方式的代码。10个线程
using namespace boost::asio;
io_service service;
struct client {
ip::tcp::socket sock;
streambuf buff; // reads the answer from the client
}
std::vector<client> clients;
void handle_clients() {
for ( int i = 0; i < clients.size(); ++i)
async_read_until(clients[i].sock, clients[i].buff, '\n',
boost::bind(on_read, clients[i], _1, _2));
for ( int i = 0; i < 10; ++i)
boost::thread(handle_clients_thread);
}
void handle_clients_thread() {
service.run();
}
void on_read(client & c, const error_code & err, size_t read_bytes) {
std::istream in(&c.buff);
std::string msg;
std::getline(in, msg);
if ( msg == "request_login")
Boost.Asio Fundamentals
[ 44 ]
c.sock.async_write( "request_ok\n", on_write);
else if ...
...
// now, wait for the next read from the same client
async_read_until(c.sock, c.buff, '\n',
boost::bind(on_read, c, _1, _2));
}
发现代码变得有多简单了吧?client结构里面唯独两个成员。handle_clients()只调用了async_read_until。然后它创建了10个线程,每一个都调用service.run()。这些线程会处理不论什么来自客户端的异步read操作。然后分发不论什么向客户端的异步write操作。另外一件须要注意的事情是:on_read()一直在为下一次异步read操作做准备(看最后一行代码)

Boost.Asio c++ 网络编程翻译(11)的更多相关文章

  1. Boost.Asio c++ 网络编程翻译(20)

    异步服务端 这个图表是相当复杂的:从Boost.Asio出来你能够看到4个箭头指向on_accept.on_read,on_write和on_check_ping. 着也就意味着你永远不知道哪个异步调 ...

  2. Boost.Asio c++ 网络编程翻译(14)

    保持活动 假如,你须要做以下的操作: io_service service; ip::tcp::socket sock(service); char buff[512]; ... read(sock, ...

  3. Boost.Asio c++ 网络编程翻译(26)

    Boost.Asio-其他特性 这章我们讲了解一些Boost.Asio不那么为人所知的特性.标准的stream和streambuf对象有时候会更难用一些,但正如你所见.它们也有它们的益处.最后,你会看 ...

  4. Boost.Asio c++ 网络编程翻译(21)

    同步VS异步 Boost.Asio的作者做了一个非常惊艳的工作:它能够让你在同步和异步中自由选择,从而更好的适应你的应用. 在之前的章节中,我们学习了每种类型应用的框架,比方同步client,同步服务 ...

  5. Boost.Asio c++ 网络编程翻译(16)

    TCP异步服务端 核心功能和同步服务端的功能类似,例如以下: class talk_to_client : public boost::enable_shared_from_this<talk_ ...

  6. Boost.Asio c++ 网络编程翻译(10)

    read/write方法 这些方法对一个流进行读写操作(能够是套接字,或者其它表现的像流的类): async_read(stream, buffer [, completion],handler):这 ...

  7. Boost.Asio c++ 网络编程翻译(18)

    同步服务端 同步服务端也相当简单.它须要两个线程,一个负责接收新的client.另外一个负责处理已经存在的client. 它不能使用单线程:等带一个新的client是一个堵塞操作,所以我们须要另外一个 ...

  8. boost.asio系列——socket编程

    asio的主要用途还是用于socket编程,本文就以一个tcp的daytimer服务为例简单的演示一下如何实现同步和异步的tcp socket编程. 客户端 客户端的代码如下: #include &l ...

  9. 使用boost.asio实现网络通讯

    #include <boost/asio.hpp> #define USING_SSL //是否加密 #ifdef USING_SSL #include <boost/asio/ss ...

随机推荐

  1. AspNetPager分页控件官方网站

    原文发布时间为:2009-12-04 -- 来源于本人的百度文章 [由搬家工具导入] http://www.webdiyer.com/AspNetPager

  2. 编译安装的php 安装pdo_mysql扩展(php版本5.6.29)

    1.进入扩展目录 cd /etc/php-/ext/pdo_mysql/ 注:根据自己情况做适当改变 2.执行phpize /etc/php-/scripts/phpize 3.编译 ./config ...

  3. linux下的用户管理(一)

    linux下有三类用户: 1.超级用户:root具有操作系统的一切权限,UID值为0的是超级用户 2.普通用户:只具有操作系统有限的权限,UID是从500到6000范围 3.伪用户:是为了方便系统管理 ...

  4. Android Bluetooth抓包

    1. 前提 这里介绍一种在Android上捕获蓝牙数据包的方法 首先你要有一部Android手机:然后你的Android系统版本要在4.4及以上 我没有做过Android开发,不清楚开发者们是如何抓蓝 ...

  5. netbean下搭建mariadb数据库

    本人的操作系统Manjaro 最新版,mariadb版本为10.1.1,使用netbeasn开发java WEB,搭建过程如下: 1.安装数据库 pacman -S mariadb 2.启动数据库服务 ...

  6. python第三方库安装和卸载

    库的安装与卸载 pip install requests pip uninstall requests 查看安装好的库 pip list   第三方库的各种安装方式如下: 一.包管理器 Python有 ...

  7. Android Studio中删除所有的断点

    直接上图,我相信你们能看的懂,骚年们. 第1个图:Run–>>View Breakpoints.. 第2个图:现在可以看到所有的断点了,在左侧栏全选,然后点"-",就全 ...

  8. python笔记7:优雅的python

    7. 如何让python代码更 Pythonic : 1.变量交换: a, b = b, a 2.带有索引位置的集合遍历: colors = ['red', 'green', 'blue', 'yel ...

  9. ELK之filebeat收集多类型日志

    1.IP规划 10.0.0.33:filebeat+tomcat,filebeat收集系统日志.tomcat日志发送到logstash 10.0.0.32:logstash,将日志写入reids(in ...

  10. f5长连接策略

    但是把这些短连接汇聚到一起,集中F5的设备上,通过F5与服务器建立平滑的长连接,就解决了不断增大的并发连接.比如说前台有15万个并发连接,经过F5的优化,在服务器上只有不到5000个并发连接,而且在此 ...