提高截止时间_计时器持有对对象的引用

Question

I'm working with a boost deadline_timer which appears to be calling its handler after the owning object has been deleted. I've tried a couple of approaches to get this to work.

First I just used the timer by binding to a handler and the owning object using 'shared_from_this'

m_timer.expires_from_now(boost::posix_time::seconds(m_nHandshakeTimeout));
m_timer.async_wait(
    boost::bind(&CTcpSslSocket::handle_handshake_timeout, 
    shared_from_this(),
    boost::asio::placeholders::error)
    );

This method makes the timer function correctly but also causes a reference to the owning object to be held. I show that I've leaked the owning object when shutting down the application. I ran into a similar issue a while ago which was resolved using a weak pointer (thanks to help from others here at stackoverflow). I tried the same thing with the timer by doing this:

m_timer.expires_from_now(boost::posix_time::seconds(m_nHandshakeTimeout));
boost::weak_ptr<CTcpSslSocket> weak( shared_from_this() );
m_timer.async_wait([=]( const boost::system::error_code& error ) {
    boost::shared_ptr<CTcpSslSocket> strong(weak);
    if ( strong ) {
        strong->handle_handshake_timeout(error);
    }
    return;
});

This also appears to work correctly as far as the timer functionality goes, but causes memory corruption when shutting down the application. Running in the debugger shows that the exception occurs while boost code is calling the handler.

If the operation I use the timer for completes within the given time I cancel the timer, otherwise I don't do anything with the timer. Here's the cancel code:

if ( m_eHandshakeTimer != eExpired )
{
    m_eHandshakeTimer = eCanceled;
    m_timer.cancel();
}

Any ideas about how to solve this?

Answer 1

Of course, holding a weak pointer does nothing to keep the object (CTcpSslSocket) alive.

A weak pointer is only able to observe the lifetime end of an object owned by a shared pointer.

Make the async operation share ownership instead. This way, when you detect the timer has been canceled, then automatically you will free the shared object.

m_timer.expires_from_now(boost::posix_time::seconds(m_nHandshakeTimeout));
auto This = shared_from_this();
m_timer.async_wait([=]( const boost::system::error_code& error ) {
    if (ec != boost::asio::error::operation_aborted) {
        This->handle_handshake_timeout(error); 
           //  ^ could share This with other handlers to keep it alive
    }
    return;
});