shared_from_this 导致 bad_weak_ptr

Question

我正在尝试在 asio 中保留已连接客户端的列表。我已经改编了文档中的聊天服务器示例（ http://www.boost.org/doc/libs/1_57_0/doc/html/boost_asio/example/cpp03/chat/chat_server.cpp ），这是重要的部分我最终得到：

 #include <iostream>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/asio.hpp>
#include <set>

using boost::asio::ip::tcp;

class tcp_connection;

std::set<boost::shared_ptr<tcp_connection>> clients;

void add_client(boost::shared_ptr<tcp_connection> client)
{
    clients.insert(client);
}

class tcp_connection : public boost::enable_shared_from_this<tcp_connection>
{
public:
    tcp_connection(boost::asio::io_service& io_service) : socket_(io_service)
    {
    }

    tcp::socket socket_;

    void start()
    {
        add_client(shared_from_this());
    }

    tcp::socket& socket()
    {
        return socket_;
    }
};

class tcp_server
{
public:
    tcp_server(boost::asio::io_service& io_service)
        : io_service_(io_service),
        acceptor_(io_service, tcp::endpoint(tcp::v4(), 6767))
    {
        tcp_connection* new_connection = new tcp_connection(io_service_);
        acceptor_.async_accept(new_connection->socket(),
                             boost::bind(&tcp_server::start_accept, this, new_connection,
                                         boost::asio::placeholders::error));
    }

private:
    void start_accept(tcp_connection* new_connection,
                      const boost::system::error_code& error)
    {
        if (!error)
        {
            new_connection->start();
            new_connection = new tcp_connection(io_service_);
            acceptor_.async_accept(new_connection->socket(),
                                   boost::bind(&tcp_server::start_accept, this, new_connection,
                                               boost::asio::placeholders::error));
        }
    }

    boost::asio::io_service& io_service_;
    tcp::acceptor acceptor_;
};

int main()
{
    try
    {
        boost::asio::io_service io_service;
        tcp_server server(io_service);
        io_service.run();
    }
    catch (std::exception& e)
    {
        std::cerr << "Exception: " << e.what() << "\n";
    }

    return 0;
}

在调用 shared_from_this() 时，我的服务器崩溃并显示以下消息：

例外：tr1::bad_weak_ptr

我已经进行了一些搜索，它似乎 shared_from_this() 非常特别，但我似乎无法找到我需要更改的确切内容。

原文由 chrisvj 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 1

John Zwinck 的基本分析如下：

错误是您在没有 shared_ptr 指向它的对象上使用 shared_from_this() 。这违反了 shared_from_this() 的前提条件，即必须已经创建了至少一个指向 this 的 shared_ptr（并且仍然存在）。

然而，他的建议在 Asio 代码中似乎完全站不住脚并且很危险。

您应该通过 - 实际上 - 首先不处理指向 tcp_connection 的原始指针，而是始终使用 shared_ptr 来解决这个问题。

boost::bind 具有绑定到 shared_ptr<> 的令人敬畏的功能，所以只要一些异步操作对其进行操作，它就会自动保持指向对象的活动状态。

这 - 在您的示例代码中 - 意味着您不需要 clients 向量，与约翰的回答相反：

 void start_accept()
{
    tcp_connection::sptr new_connection = boost::make_shared<tcp_connection>(io_service_);
    acceptor_.async_accept(new_connection->socket(),
            boost::bind(
                &tcp_server::handle_accept,
                this, new_connection, asio::placeholders::error
            )
        );
}

void handle_accept(tcp_connection::sptr client, boost::system::error_code const& error)
{
    if (!error)
    {
        client->start();
        start_accept();
    }
}

我已经包含了一个示例，使 tcp_connection 做一些琐碎的工作（它每秒循环向客户端写入“hello world”，直到客户端断开连接。当它这样做时，你可以看到析构函数 tcp_connection 正在运行的操作：

住在科利鲁

#include <iostream>
#include <boost/bind.hpp>
#include <boost/make_shared.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/asio.hpp>
#include <boost/thread.hpp>

namespace asio = boost::asio;
using asio::ip::tcp;

class tcp_connection : public boost::enable_shared_from_this<tcp_connection>
{
public:
    typedef boost::shared_ptr<tcp_connection> sptr;

    tcp_connection(asio::io_service& io_service) : socket_(io_service), timer_(io_service)
    {
    }

    void start()
    {
        std::cout << "Created tcp_connection session\n";

        // post some work bound to this object; if you don't, the client gets
        // 'garbage collected' as the ref count goes to zero
        do_hello();
    }

    ~tcp_connection() {
        std::cout << "Destroyed tcp_connection\n";
    }

    tcp::socket& socket()
    {
        return socket_;
    }

  private:
    tcp::socket socket_;
    asio::deadline_timer timer_;

    void do_hello(boost::system::error_code const& ec = {}) {
        if (!ec) {
            asio::async_write(socket_, asio::buffer("Hello world\n"),
                    boost::bind(&tcp_connection::handle_written, shared_from_this(), asio::placeholders::error, asio::placeholders::bytes_transferred)
                );
        }
    }

    void handle_written(boost::system::error_code const& ec, size_t /*bytes_transferred*/) {
        if (!ec) {
            timer_.expires_from_now(boost::posix_time::seconds(1));
            timer_.async_wait(boost::bind(&tcp_connection::do_hello, shared_from_this(), asio::placeholders::error));
        }
    }
};

class tcp_server
{
public:
    tcp_server(asio::io_service& io_service)
        : io_service_(io_service),
          acceptor_(io_service, tcp::endpoint(tcp::v4(), 6767))
    {
        start_accept();
    }

private:
    void start_accept()
    {
        tcp_connection::sptr new_connection = boost::make_shared<tcp_connection>(io_service_);
        acceptor_.async_accept(new_connection->socket(),
                boost::bind(
                    &tcp_server::handle_accept,
                    this, new_connection, asio::placeholders::error
                )
            );
    }

    void handle_accept(tcp_connection::sptr client, boost::system::error_code const& error)
    {
        if (!error)
        {
            client->start();
            start_accept();
        }
    }

    asio::io_service& io_service_;
    tcp::acceptor acceptor_;
};

int main()
{
    try
    {
        asio::io_service io_service;
        tcp_server server(io_service);

        boost::thread(boost::bind(&asio::io_service::run, &io_service)).detach();

        boost::this_thread::sleep_for(boost::chrono::seconds(4));
        io_service.stop();
    }
    catch (std::exception& e)
    {
        std::cerr << "Exception: " << e.what() << "\n";
    }
}

典型输出：

 sehe@desktop:/tmp$ time (./test& (for a in {1..4}; do nc 127.0.0.1 6767& done | nl&); sleep 2; killall nc; wait)
Created tcp_connection session
Created tcp_connection session
     1  Hello world
Created tcp_connection session
     2  Hello world
Created tcp_connection session
     3  Hello world
     4  Hello world
     5  Hello world
     6  Hello world
     7  Hello world
     8  Hello world
     9  Hello world
    10  Hello world
    11  Hello world
    12  Hello world
    13
Destroyed tcp_connection
Destroyed tcp_connection
Destroyed tcp_connection
Destroyed tcp_connection
Destroyed tcp_connection

real    0m4.003s
user    0m0.000s
sys 0m0.015s

原文由 sehe 发布，翻译遵循 CC BY-SA 3.0 许可协议

Answer 2

错误是您在没有 shared_ptr 指向它的对象上使用 shared_from_this() 。这违反了 shared_from_this() 的先决条件，即必须 已经 创建（并且仍然存在）至少一个 shared_ptr 指向 this 。

您的问题的根本原因似乎是您最初将 new 的结果存储在原始指针中。您应该将 new 的结果存储在智能指针中（总是，基本上）。那么，也许您可以立即将智能指针存储在您的 clients 列表中。

我在评论中提到的另一种方法是完全停止使用 shared_from_this() 。你不需要它。至于你提到的这段代码：

 if ((boost::asio::error::eof == ec) || (boost::asio::error::connection_reset == ec))
{
    clients.erase(shared_from_this());
}

您可以通过以下方式替换它：

 if ((boost::asio::error::eof == ec) || (boost::asio::error::connection_reset == ec))
{
    boost::shared_ptr<tcp_connection> victim(this, boost::serialization::null_deleter());
    clients.erase(victim);
}

也就是说，创建一个永远不会解除分配（ https://stackoverflow.com/a/5233034/4323 ）的“哑”智能指针，但它会为您提供从客户端列表中删除它所需的内容。还有其他方法可以做到这一点，例如通过使用比较函数搜索 std::set 使用一个 shared_ptr 和一个原始指针并知道比较它们指向的地址。你选择哪种方式并不重要，但你完全摆脱了 shared_from_this() 的情况。

原文由 John Zwinck 发布，翻译遵循 CC BY-SA 3.0 许可协议