asio（五）、同步多线程处理时间

最新推荐文章于 2024-10-10 20:49:55 发布

牛马不分

最新推荐文章于 2024-10-10 20:49:55 发布

阅读量490

点赞数

分类专栏： asio 文章标签： c++

本文链接：https://blog.youkuaiyun.com/weijianjain/article/details/129703522

版权

asio 专栏收录该内容

13 篇文章

订阅专栏

该教程介绍了如何在多线程环境中使用ASIO库的strand类来同步处理程序，确保它们不会并发访问共享资源。通过创建一个strand对象并将其与异步操作绑定，可以保证即使在多线程调用io_context::run()的情况下，处理程序也会按顺序执行。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

官网教程：https://think-async.com/Asio/asio-1.26.0/doc/asio/tutorial/tuttimer5.html

在多线程程序中使用strand类模板来同步完成处理程序。

前面的四个教程通过仅从一个线程调用io_context::run()函数来避免处理程序同步的问题。正如您已经知道的，asio库提供了一种保证，即完成处理程序将仅从当前正在调用io_context::run()的线程中调用。因此，只从一个线程调用io_context::run()可以确保完成处理程序不能并发运行。

使用asio开发应用程序时，单线程方法通常是最佳的起点。缺点是它对程序（尤其是服务器）的限制，包括：

当处理程序可能需要很长时间才能完成时，响应能力较差。

无法在多处理器系统上进行扩展。

如果您发现自己遇到了这些限制，另一种方法是使用一个调用io_context::run()的线程池。然而，由于这允许处理程序并行执行，当处理程序可能访问共享的、线程不安全的资源时，我们需要一种同步方法。

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

我们首先定义一个名为printer的类，类似于上一教程中的类。这个类将通过并行运行两个定时器来扩展上一个教程。

class printer
{
public:

除了初始化一对asio::steady_timer成员外，构造函数还初始化strand_member，这是一个类型为asico::strandasio::io_context::executor_type的对象。

strand类模板是一个执行器适配器，它保证对于通过它调度的处理程序，一个执行处理程序将被允许在下一个启动之前完成。无论调用io_context::run()的线程数量如何，都可以保证这一点。当然，这些处理程序仍然可以与其他未通过一个strand调度的处理程序同时执行，或者通过不同的strand对象调度。


    printer(asio::io_context& io)
        : strand_(asio::make_strand(io)),
        timer1_(io, asio::chrono::seconds(1)),
        timer2_(io, asio::chrono::seconds(1)),
        count_(0)
    {

在启动异步操作时，每个完成处理程序都“绑定”到一个asio::strandasio::io_context::executor_type对象。asio::bind_executor()函数返回一个新的处理程序，该处理程序通过strand对象自动调度其包含的处理程序。通过将处理程序绑定到同一个链，我们可以确保它们不能并发执行。

        timer1_.async_wait(asio::bind_executor(strand_,
            boost::bind(&printer::print1, this)));

        timer2_.async_wait(asio::bind_executor(strand_,
            boost::bind(&printer::print2, this)));
    }

    ~printer()
    {
        std::cout << "Final count is " << count_ << std::endl;
    }

在多线程程序中，如果异步操作的处理程序访问共享资源，则它们应该同步。在本教程中，处理程序（print1和print2）使用的共享资源是std::cout和count_data成员。

 void print1()
    {
        if (count_ < 10)
        {
            std::cout << "Timer 1: " << count_ << std::endl;
            ++count_;

            timer1_.expires_at(timer1_.expiry() + asio::chrono::seconds(1));

            timer1_.async_wait(asio::bind_executor(strand_,
                boost::bind(&printer::print1, this)));
        }
    }

    void print2()
    {
        if (count_ < 10)
        {
            std::cout << "Timer 2: " << count_ << std::endl;
            ++count_;

            timer2_.expires_at(timer2_.expiry() + asio::chrono::seconds(1));

            timer2_.async_wait(asio::bind_executor(strand_,
                boost::bind(&printer::print2, this)));
        }
    }

private:
    asio::strand<asio::io_context::executor_type> strand_;
    asio::steady_timer timer1_;
    asio::steady_timer timer2_;
    int count_;
};

主函数现在导致从两个线程调用io_context::run()主线程和一个附加线程。这是使用线程对象完成的。

就像对单个线程的调用一样，对io_context::run()的并发调用将在还有“工作”要做的时候继续执行。在所有异步操作完成之前，后台线程不会退出。

int main()
{
    asio::io_context io;
    printer p(io);
    asio::thread t(boost::bind(&asio::io_context::run, &io));
    io.run();
    t.join();

    return 0;
}

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

class printer
{
public:
    printer(asio::io_context& io)
        : strand_(asio::make_strand(io)),
        timer1_(io, asio::chrono::seconds(1)),
        timer2_(io, asio::chrono::seconds(1)),
        count_(0)
    {
        timer1_.async_wait(asio::bind_executor(strand_,
            boost::bind(&printer::print1, this)));

        timer2_.async_wait(asio::bind_executor(strand_,
            boost::bind(&printer::print2, this)));
    }

    ~printer()
    {
        std::cout << "Final count is " << count_ << std::endl;
    }

    void print1()
    {
        if (count_ < 10)
        {
            std::cout << "Timer 1: " << count_ << std::endl;
            ++count_;

            timer1_.expires_at(timer1_.expiry() + asio::chrono::seconds(1));

            timer1_.async_wait(asio::bind_executor(strand_,
                boost::bind(&printer::print1, this)));
        }
    }

    void print2()
    {
        if (count_ < 10)
        {
            std::cout << "Timer 2: " << count_ << std::endl;
            ++count_;

            timer2_.expires_at(timer2_.expiry() + asio::chrono::seconds(1));

            timer2_.async_wait(asio::bind_executor(strand_,
                boost::bind(&printer::print2, this)));
        }
    }

private:
    asio::strand<asio::io_context::executor_type> strand_;
    asio::steady_timer timer1_;
    asio::steady_timer timer2_;
    int count_;
};

int main()
{
    asio::io_context io;
    printer p(io);
    asio::thread t(boost::bind(&asio::io_context::run, &io));
    io.run();
    t.join();

    return 0;
}