boost asio 介绍 关于strand的介绍不错

http://blog.csdn.net/ithiker/article/details/22153001

 

Boost Asio ( asynchronous input and output)关注异步输入输出。Boost Asio库提供了平台无关性的异步数据处理能力（当然它也支持同步数据处理）。一般的数据传输过程需要通过函数的返回值来判断数据传输是否成功。Boost Asio将数据传输分为两个独立的步骤：

1. 采用异步任务的方式开始数据传输。
2. 将传输结果回掉通知调用端

        与传统方式相比，优点在于程序在数据传输期间不会阻塞。

二 I/O services and I/O objects

        应用程序采用Boost.Asio进行异步数据处理主要基于 I/O services 和 I/O objects。I/O services抽象系统I/O接口,提供异步数据传输的能力，它是应用程序和系统I/O接口的桥梁。I/O objects 用来初始化某些特定操作，如TCP socket，提供TCP方面可靠数据传输的能力。Boost.Asio只提供一个类实现 I/O services, boost::asio::io_service。提供多个I/O objects对象，如boost::asio::ip::tcp::socket（用来收发数据）和boost::asio::deadline_timer（用来提供计时器的功能，计时器可以在某个时间点或经历某个时间段后生效）。

 

#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <iostream>

void handler1(const boost::system::error_code &ec)
{
　　std::cout << "5 s." << std::endl;
}

void handler2(const boost::system::error_code &ec)
{
　　std::cout << "5 s." << std::endl;
}

boost::asio::io_service io_service;  //全局的io_service

void run()
{
　　io_service.run();
}

int main()
{
　　boost::asio::deadline_timer timer1(io_service, boost::posix_time::seconds(5));
　　timer1.async_wait(handler1);
　　boost::asio::deadline_timer timer2(io_service, boost::posix_time::seconds(5));
　　timer2.async_wait(handler2);

//timer1和timer2的handler注册在同一个io_service上，并且两个线程运行在同一个io_service上，所以handler1,handler2可以运行在任意一个线程上
　　boost::thread thread1(run);
　　boost::thread thread2(run);
　　thread1.join();
　　thread2.join();
}

 

采用boost::asio::io_service调用run()方法，和boost::asio::io_service相关联的handler将会在同一线程内(调用run()方法的线程内)触发。通过采用多线程，应用程序可以同时调用多个run()方法。一旦某个异步操作完成，对应的I/O service将会执行某个线程中的handler方法。如果第二个异步操作在第一个结束后很快完成，I/O service 可以立刻执行其对应的handler,而不用等待第一个handler执行完毕。

线程可以增加程序的执行效率。因为线程跑在CPU的核上，创建比CPU核数还多的线程是没有意义的。这可以保证每个线程跑在各自的核上，而不会出现多个线程为抢占某个核的”核战争”。

 

应该注意到，采用线程也不是总是合理的。如果它们需要访问共享资源，则需要同步手段。

如果线程各自的handler不能独立的并行执行(handler1的输出可能影响到handler2)，在这种场景下使用线程不会带来什么好处。

 

 

基于Boost.Asio来提高程序的可扩展性推荐的方法是：采用单个I/O service多次调用run()方法。当然，也有另外的方法可以选择：可以创建多个I/O service，而不是将所有的线程都绑定到一个I/O service上。每个I/O service对应于一个线程【one loop per thread】。

如果I/O service的个数和计算机的核数相匹配，异步操作将会在各自对应的核上运行。

 

 

 

＝＝＝＝＝＝＝＝＝＝＝＝＝＝

http://blog.csdn.net/ithiker/article/details/22600489

#include <boost/asio.hpp>
#include <iostream>

int main( int argc, char * argv[] )
{
　　boost::asio::io_service io_service;
　　boost::asio::io_service::work work( io_service );    //给io_service work，keep it running

　　io_service.run();

　　std::cout << "Do you reckon this line displays?" << std::endl;

　　return 0;
}

 

如果不喜欢用阻塞的方法（io_service.run()）来运行事件处理，Boost.Asio也提供了其它类似BSD socket的任务调度方法，poll就是其中之一。poll调用io_service的事件循环来运行已经就绪的handler方法

poll方法是非阻塞的，它只是检查当前工作队列中是否有就绪的，有就执行，执行完成后立刻返回。

 

 

#include <boost/asio.hpp>
#include <iostream>

int main( int argc, char * argv[] )
{
boost::asio::io_service io_service;
boost::asio::io_service::work work( io_service );

while(1)
{
io_service.poll();
}
std::cout << "end loop: " << std::endl;

return 0;
}

 

从io_service中删除work会使io_service.run()结束阻塞状态，但是io_service并没有这样的成员函数，这时必须通过智能指针来实现：通过reset智能指针来删除智能指针所指向的对象，这样就可以很优雅的移除work了。

 

 

 

#include <boost/asio.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/bind.hpp>
#include <iostream>

boost::mutex global_stream_lock;

void WorkerThread( boost::shared_ptr< boost::asio::io_service > io_service )
{
	global_stream_lock.lock();
	std::cout << "[" << boost::this_thread::get_id()
		<< "] Thread Start" << std::endl;
	global_stream_lock.unlock();

	io_service->run();                      //worker线程run()

	global_stream_lock.lock();
	std::cout << "[" << boost::this_thread::get_id()
		<< "] Thread Finish" << std::endl;
	global_stream_lock.unlock();
}

void Dispatch( int x )
{
	global_stream_lock.lock();
	std::cout << "[" <<  boost::this_thread::get_id()  << "] "
		<< __FUNCTION__  << " x = " << x <<  std::endl;
	global_stream_lock.unlock();
}

void Post( int x )
{
	global_stream_lock.lock();
	std::cout << "[" <<  boost::this_thread::get_id()  << "] "
		<< __FUNCTION__  << " x = " << x <<  std::endl;
	global_stream_lock.unlock();
}

void Run3( boost::shared_ptr< boost::asio::io_service > io_service )
{
	for( int x = 0; x < 3; ++x )
	{
		io_service->dispatch( boost::bind( &Dispatch, x * 2 ) );
		io_service->post( boost::bind( &Post, x * 2 + 1 ) );
		boost::this_thread::sleep( boost::posix_time::milliseconds( 1000 ) );
	}
}

int main( int argc, char * argv[] )
{
	boost::shared_ptr< boost::asio::io_service > io_service(
		new boost::asio::io_service
	);
	boost::shared_ptr< boost::asio::io_service::work > work(
		new boost::asio::io_service::work( *io_service )
	);

	global_stream_lock.lock();
	std::cout << "[" <<  boost::this_thread::get_id()
		<< "] The program will exit when all  work has finished." <<  std::endl;
	global_stream_lock.unlock();

	boost::thread_group worker_threads;
	for( int x = 0; x < 1; ++x )      //线程个数可调整
	{
		worker_threads.create_thread( boost::bind( &WorkerThread, io_service ) );    //一个io_service
	}

	io_service->post( boost::bind( &Run3, io_service ) );        //主线程中Post任务

	work.reset();

	worker_threads.join_all();

	return 0;
}

• 　dispatch()投递任务，如果当前投递任务的线程也调用了io_service.run()方法，则任务会在dispatch()内部被立即执行。(如果调用post()函数的当前线程就是任务所属的线程，任务会被立即执行)) 。

相当于muduo的void EventLoop::runInLoop(const Functor& cb);

http://www.boost.org/doc/libs/1_59_0/doc/html/boost_asio/reference/io_service/dispatch.html

 

•    post()只负责投递任务并立即返回，不管当前投递任务的线程是否调用了io_service.run()方法，post()方法的内部都不会执行该任务(即使调用post()函数的当前线程就是任务所属的线程，任务也不会被执行，只进行任务的入队操作)。

相当于muduo的void EventLoop::queueInLoop(const Functor& cb);　　

但是还不太一样，因为post()的io_service可能会有多个线程，而queueInLoop特定于当前的单个线程。

 

http://www.boost.org/doc/libs/1_59_0/doc/html/boost_asio/reference/io_service/post.html

Request the io_service to invoke the given handler and return immediately.  （请求执行(不会立即执行，只是请求io_service在将来的某个时刻执行)，并立即返回）

This function is used to ask the io_service to execute the given handler, but without allowing the io_service to call the handler from inside this function.（不允许立即执行）

 

http://www.cnblogs.com/my_life/articles/4806314.html

我们发现，输出没有按照顺序输出，这是因为只有一个线程(x < 1)，dispatch在此时不管工作队列中有多少任务都会优先执行(在dispatch内部自动被执行)，而post则要等待队列中的其它完成后再执行(post只负责投递任务，

任务何时被执行，取决于执行调用io_service.post()的io_service对象被run()的线程个数，在当前例子中，只有一个线程，所以看上去是等所有dispatch的任务执行完成后才被执行的)；

如果线程改为2个或更多，就是顺序输出了，这是因为有sleep的存在，去掉sleep后输出取决于谁先获得锁。如果工作有先后顺序，采用上面的方法显然是不能达到预期的。

多个线程就顺序输出了，这是因为dispatch()立马就能输出，随后的post()可以在其他线程中‘’立马‘’(因为任务少，其他线程的任务队列是空，看上去post的任务得到了立马执行)得到执行，这就顺序了。

 

 

 

默认情况下，一个service多个线程的情况下，你是不知道每个异步handler的调用顺序的。你可以使用service.post()来使你的自定义方法被异步地调用。

#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <iostream>
using namespace boost::asio;
io_service service;          //一个service
void func(int i) {
    std::cout << "func called, i= " << i << std::endl;
}

void worker_thread() {
    service.run();
}

int main(int argc, char* argv[]) {
    for ( int i = 0; i < 10; ++i)
        service.post(boost::bind(func, i));
    boost::thread_group threads;
    for ( int i = 0; i < 3; ++i)               //多个线程
        threads.create_thread(worker_thread);
    // 等待所有线程被创建完
    boost::this_thread::sleep( boost::posix_time::millisec(500));
    threads.join_all();
}

service.post(some_function)添加了一个异步方法调用。

这个方法在某一个调用了service.run()的线程中请求io_service实例，然后调用给定的some_funtion之后立即返回。在我们的例子中，这个线程是我们之前创建的三个线程中的一个。你不能确定异步方法调用的顺序。你不要期待它们会以我们调用post()方法的顺序来调用。

 

有时候你会想让一些异步处理方法顺序执行。比如，你去一个餐馆（go_to_restaurant），下单（order），然后吃（eat）。你需要先去餐馆，然后下单，最后吃。这样的话，你需要用到io_service::strand，这个方法会让你的异步方法被顺序调用。

 http://www.boost.org/doc/libs/1_43_0/doc/html/boost_asio/reference/io_service__strand.html

解决上面的问题，boost提供了strand来给工作排序。strand能够保证handler有序执行，也就是说，如果我们通过strand给io_services post了work1->work2-->work3，不管有多少线程，它们都会按照那个顺序执行。

下面是strand使用的一些规则，这对使用strand至关重要，如果我们不太了解，编写的代码可能会产生未定义的行为，导致运行很长时间，有时程序崩溃也很难排查。

规则：

如果有：strand s；满足完成处理要求的对象a，b；a，b的拷贝a1，b1;  【a1, b1是异步操作的回调handler被bind拷贝出来的】

当下面的任何之一条件成立：

• s.post(a)早于s.post(b)
• s.post(a)早于s.dispatch(b),后者在strand外进行
• s.dispatch(a)早于s.post(b),前者在strand外进行
• s.dispatch(a)早于s.dispatch(b),两者均在strand外进行

只要有dispatch(), 其就必须在strand外进行才能保证顺序

那么：asio_handler_invoke(a1,&a1)早于asio_handler_invoke(b1,&b1)

但是，如果像下面的情况：

async_op_1(..., s.wrap( a ));
async_op_2(..., s.wrap( b ));

此时，这两个异步操作都会调用对应的dispatch，但是我们不知道dispatch(a)和dispach(b)的顺序。也就是说，上面任何一个条件都不满足，此时就不能决定二者的顺序。

The io_service::strand class provides the ability to post and dispatch handlers with the guarantee that none of those handlers will execute concurrently. 

strand::post(), strand::dispatch()都会保证不会并发，但顺序的保证条件比较严格。

The strand object guarantees that handlers posted or dispatched through the strand will not be executed concurrently.

strand保证所有的handler不会被同时执行，但其不保证有序执行。要想顺序就得满足上面提到的四个条件之一。

英文版在这里：

http://www.gamedev.net/blog/950/entry-2249317-a-guide-to-getting-started-with-boostasio?pg=5

Order of handler invocation

Given:

• a strand object s
• an object a meeting completion handler requirements
• an object a1 which is an arbitrary copy of a made by the implementation（异步事件完成时执行的handler拷贝）
• an object b meeting completion handler requirements
• an object b1 which is an arbitrary copy of b made by the implementation

if any of the following conditions are true:

• s.post(a) happens-before s.post(b)    //post一如既往只负责投递任务，然后立即返回
• s.post(a) happens-before s.dispatch(b), where the latter is performed outside the strand
• s.dispatch(a) happens-before s.post(b), where the former is performed outside the strand
• s.dispatch(a) happens-before s.dispatch(b), where both are performed outside the strand

then asio_handler_invoke(a1, &a1) happens-before asio_handler_invoke(b1, &b1).

Note that in the following case:

async_op_1(..., s.wrap(a));
async_op_2(..., s.wrap(b)); 

the completion of the first async operation will perform s.dispatch(a), and the second will perform s.dispatch(b), but the order in which those are performed is unspecified. That is, you cannot state whether one happens-before the other. Therefore none of the above conditions are met and no ordering guarantee is made.

 

io_service::strand::dispatch   如果可能，dispatch()内部会直接运行handler()

Request the strand to invoke the given handler.

The handler may be executed inside this function if the guarantee can be met. If this function is called from within a handler that was posted or dispatched through the same strand, then the new handler will be executed immediately.

（如果dispatch()是在某个通过同一个strand的触发的回调函数handler内被调用的, 那么新的handler将立即得到执行）

The strand's guarantee is in addition to the guarantee provided by the underlying io_service. The io_service guarantees that the handler will only be called in a thread in which the io_service's run member function is currently being invoked.

 

io_service::strand::post   投递任务，在其内部肯定不会直接运行handler()

Request the strand to invoke the given handler and return immediately.

This function is used to ask the strand to execute the given handler, but without allowing the strand to call the handler from inside this function. 内部不允许strand调用被投递的handler

 

The strand object guarantees that handlers posted or dispatched through the strand will not be executed concurrently. The strand's guarantee is in addition to the guarantee provided by the underlying io_service.

Theio_service guarantees that the handler will only be called in a thread in which the io_service's run member function is currently being invoked.

 

io_service::strand::wrap   内部是调用dispatch()，所以还是无序的

This function is used to create a new handler function object that, when invoked, will automatically pass the wrapped handler to the strand's dispatch function.

       

  下面是例子，注意，去掉了标准输出上的锁，采用多线程：

 

#include <boost/asio.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/bind.hpp>
#include <iostream>

boost::mutex global_stream_lock;

void WorkerThread( boost::shared_ptr< boost::asio::io_service > io_service )
{
    global_stream_lock.lock();
    std::cout << "[" << boost::this_thread::get_id() << "] Thread Start" << std::endl;
    global_stream_lock.unlock();

    io_service->run();

    global_stream_lock.lock();
    std::cout << "[" << boost::this_thread::get_id()
        << "] Thread Finish" << std::endl;
    global_stream_lock.unlock();
}

void PrintNum( int x )
{
    std::cout << "[" << boost::this_thread::get_id()
        << "] x: " << x << std::endl;
}

int main( int argc, char * argv[] )
{
    boost::shared_ptr< boost::asio::io_service > io_service(
        new boost::asio::io_service
    );
    boost::shared_ptr< boost::asio::io_service::work > work(
        new boost::asio::io_service::work( *io_service )
    );
    boost::asio::io_service::strand strand( *io_service );

    global_stream_lock.lock();
    std::cout << "[" <<  boost::this_thread::get_id()
        << "] The program will exit when all  work has finished." <<  std::endl;
    global_stream_lock.unlock();

    boost::thread_group worker_threads;
    for( int x = 0; x < 4; ++x )
    {
        worker_threads.create_thread( boost::bind( &WorkerThread, io_service ) );              //一个service多个线程
    }

    boost::this_thread::sleep( boost::posix_time::milliseconds( 100 ) );
    io_service->post( strand.wrap( boost::bind( &PrintNum, 1 ) ) );
    io_service->post( strand.wrap( boost::bind( &PrintNum, 2 ) ) );

    boost::this_thread::sleep( boost::posix_time::milliseconds( 100 ) );
    io_service->post( strand.wrap( boost::bind( &PrintNum, 3 ) ) );
    io_service->post( strand.wrap( boost::bind( &PrintNum, 4 ) ) );

    boost::this_thread::sleep( boost::posix_time::milliseconds( 100 ) );
    io_service->post( strand.wrap( boost::bind( &PrintNum, 5 ) ) );
    io_service->post( strand.wrap( boost::bind( &PrintNum, 6 ) ) );

    work.reset();

    worker_threads.join_all();

    return 0;
}

 

上面都是通过io_service来post事件的(多个线程执行回调)，所以不能保证顺序

上面的strand并不能保证按需输出，改为 

strand.post( boost::bind( &PrintNum, 1 ) );

的形式就可以实现了。

也就是说，在多线程中，如果我们采用下面的A类方法，可以保证顺序，采用B，则不能；这在strand的介绍文档中有专门的说明，是因为strand的post方法保序，而strand wrap到某个方法上并不能保证整体有序。

A:     有序的俩要素：（strand， strand.post）
strand.post( boost::bind( &PrintNum, 1 ) );
strand.post( boost::bind( &PrintNum, 2 ) );
strand.post( boost::bind( &PrintNum, 3 ) );

B:  该情况只保证非并发，不保证顺序
io_service->post( strand.wrap( boost::bind( &PrintNum, 1) ) );
io_service->post( strand.wrap( boost::bind( &PrintNum, 2 ) ) );
io_service->post( strand.wrap( boost::bind( &PrintNum, 3 ) ) );
#include <boost/asio.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/bind.hpp>
#include <iostream>

boost::mutex global_stream_lock;

void WorkerThread( boost::shared_ptr< boost::asio::io_service > io_service )
{
    global_stream_lock.lock();
    std::cout << "[" << boost::this_thread::get_id()
        << "] Thread Start" << std::endl;
    global_stream_lock.unlock();

    try     //捕获异常
    {
        io_service->run();
    }
    catch( std::exception & ex )
    {
        global_stream_lock.lock();
        std::cout << "[" << boost::this_thread::get_id()
            << "] Exception: " << ex.what() << std::endl;
        global_stream_lock.unlock();
    }

    global_stream_lock.lock();
    std::cout << "[" << boost::this_thread::get_id()
        << "] Thread Finish" << std::endl;
    global_stream_lock.unlock();
}

void RaiseAnException( boost::shared_ptr< boost::asio::io_service > io_service )
{
    global_stream_lock.lock();
    std::cout << "[" << boost::this_thread::get_id()
        << "] " << __FUNCTION__ << std::endl;
    global_stream_lock.unlock();

    io_service->post( boost::bind( &RaiseAnException, io_service ) );    //第二次抛出异常
    io_service->post( boost::bind( &RaiseAnException, io_service ) );    //第三次抛出异常

    throw( std::runtime_error( "Oops!" ) );
}

int main( int argc, char * argv[] )
{
    boost::shared_ptr< boost::asio::io_service > io_service(
        new boost::asio::io_service
        );
    boost::shared_ptr< boost::asio::io_service::work > work(
        new boost::asio::io_service::work( *io_service )
        );

    global_stream_lock.lock();
    std::cout << "[" << boost::this_thread::get_id()
        << "] The program will exit when all work has finished." << std::endl;
    global_stream_lock.unlock();

    boost::thread_group worker_threads;
    for( int x = 0; x < 2; ++x )    //只创建两个线程
    {
        worker_threads.create_thread( boost::bind( &WorkerThread, io_service ) );
    }

    io_service->post( boost::bind( &RaiseAnException, io_service ) );    //第一次抛出异常

    worker_threads.join_all();

    return 0;
}
void WorkerThread( boost::shared_ptr< boost::asio::io_service > io_service )
{
    global_stream_lock.lock();
    std::cout << "[" << boost::this_thread::get_id()
        << "] Thread Start" << std::endl;
    global_stream_lock.unlock();

    boost::system::error_code ec;
    io_service->run( ec );    //使用错误码，而没使用异常捕获

    if( ec )
    {
        global_stream_lock.lock();
        std::cout << "[" << boost::this_thread::get_id()
            << "] Exception: " << ec << std::endl;
        global_stream_lock.unlock();
    }

    global_stream_lock.lock();
    std::cout << "[" << boost::this_thread::get_id()
        << "] Thread Finish" << std::endl;
    global_stream_lock.unlock();
}