c++ - MySQL异步？

Question

我基本上面临着阻塞问题。 我的服务器基于 C++ Boost.ASIO 使用 8 个线程进行编码，因为服务器有 8 个逻辑核心。

我的问题是一个线程在 MySQL 查询上可能会面临 0.2~1.5 秒的阻塞，老实说我不知道​​如何解决这个问题，因为 MySQL C++ 连接器不支持异步查询，而且我不知道如何解决“正确”设计服务器以使用多个线程进行查询。

这是我征求有关在这种情况下该怎么做的意见的地方。 为异步查询sql创建100个线程？ 我可以听取专家对此的意见吗？

Answer 1

好的，正确的解决方案是扩展 Asio 并编写一个 mysql_service 实现来集成它。我差点要去 find out how this is done right away ，但我想开始使用“仿真”。

想法是有

• 您使用 io_service 的业务流程(正如您已经在做的那样)
• 一个数据库“门面”接口(interface)，将异步查询分派(dispatch)到一个不同的队列 (io_service) 并将完成处理程序发送回 business_process io_service

这里需要进行细微的调整，您需要防止业务流程端的 io_service 在其作业队列为空时立即关闭，因为它可能仍在等待数据库层的响应。

因此，将其建模为一个快速演示:

namespace database
{
    // data types
    struct sql_statement { std::string dml; };
    struct sql_response { std::string echo_dml; }; // TODO cover response codes, resultset data etc.

我希望你能原谅我粗略的简化:/

struct service
{
    service(unsigned max_concurrent_requests = 10)
        : work(io_service::work(service_)),
        latency(mt19937(), uniform_int<int>(200, 1500)) // random 0.2 ~ 1.5s
    {
        for (unsigned i = 0; i < max_concurrent_requests; ++i)
            svc_threads.create_thread(boost::bind(&io_service::run, &service_));
    }

    friend struct connection;

private:
    void async_query(io_service& external, sql_statement query, boost::function<void(sql_response response)> completion_handler)
    {
        service_.post(bind(&service::do_async_query, this, ref(external), std::move(query), completion_handler));
    }

    void do_async_query(io_service& external, sql_statement q, boost::function<void(sql_response response)> completion_handler)
    {
        this_thread::sleep_for(chrono::milliseconds(latency())); // simulate the latency of a db-roundtrip

        external.post(bind(completion_handler, sql_response { q.dml }));
    }

    io_service service_;
    thread_group svc_threads; // note the order of declaration
    optional<io_service::work> work;

    // for random delay
    random::variate_generator<mt19937, uniform_int<int> > latency;
};

该服务协调最大数量的并发请求(在“数据库 io_service”端)并将完成的 ping/pong 返回到另一个 io_service(async_query/do_async_query 组合)。这个 stub 实现以明显的方式模拟了 0.2~1.5 秒的延迟:)

现在是客户端“门面”

struct connection
{
    connection(int connection_id, io_service& external, service& svc)
        : connection_id(connection_id),
          external_(external), 
          db_service_(svc)
    { }

    void async_query(sql_statement query, boost::function<void(sql_response response)> completion_handler)
    {
        db_service_.async_query(external_, std::move(query), completion_handler);
    }
  private:
    int connection_id;
    io_service& external_;
    service& db_service_;
};

connection 实际上只是一种便利，因此我们不必显式处理调用站点上的各种队列。

现在，让我们用古老的 Asio 风格实现一个演示业务流程:

namespace domain
{
    struct business_process : id_generator
    {
        business_process(io_service& app_service, database::service& db_service_) 
            : id(generate_id()), phase(0), 
            in_progress(io_service::work(app_service)),
            db(id, app_service, db_service_)
        { 
            app_service.post([=] { start_select(); });
        }

    private:
        int id, phase;
        optional<io_service::work> in_progress;

        database::connection db;

        void start_select() {
            db.async_query({ "select * from tasks where completed = false" }, [=] (database::sql_response r) { handle_db_response(r); });
        }

        void handle_db_response(database::sql_response r) {
            if (phase++ < 4)
            {
                if ((id + phase) % 3 == 0) // vary the behaviour slightly
                {
                    db.async_query({ "insert into tasks (text, completed) values ('hello', false)" }, [=] (database::sql_response r) { handle_db_response(r); });
                } else
                {
                    db.async_query({ "update * tasks set text = 'update' where id = 123" }, [=] (database::sql_response r) { handle_db_response(r); });
                }
            } else
            {
                in_progress.reset();
                lock_guard<mutex> lk(console_mx);
                std::cout << "business_process " << id << " has completed its work\n";
            }
        }
    };

}

此业务流程首先将其自身发布到应用服务上。然后它会连续执行一些数据库查询，并最终退出(通过执行 in_progress.reset()，应用服务会意识到这一点)。

一个演示 main，在一个线程上启动 10 个业务流程:

int main()
{
    io_service app;
    database::service db;

    ptr_vector<domain::business_process> bps;
    for (int i = 0; i < 10; ++i)
    {
        bps.push_back(new domain::business_process(app, db));
    }

    app.run();
}

在我的示例中，business_processes 不执行任何 CPU 密集型工作，因此跨 CPU 调度它们没有用处，但如果您愿意，可以通过替换 app.run() 符合:

thread_group g;
for (unsigned i = 0; i < thread::hardware_concurrency(); ++i)
    g.create_thread(boost::bind(&io_service::run, &app));
g.join_all();

查看正在运行的演示 Live On Coliru