Ticket #10721: deadlock-boost-signals2.cpp

/*
compile with:

        g++ -o deadlock-boost-signals2 deadlock-boost-signals2.cpp -lboost_signals -pthread

run with gdb or valgrind:

        valgrind --tool=helgrind ./deadlock-boost-signals2
*/

#include <assert.h>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include <boost/signals2/signal.hpp>

typedef boost::signals2::signal<void()> Signal;

class SelfReference: private boost::noncopyable
{
public:
        boost::shared_ptr<SelfReference> m_self;
        boost::shared_ptr<Signal> m_signal;

        boost::signals2::connection m_conReleaseSelf;
        boost::signals2::connection m_conDoNothing;

        SelfReference()
        {
                m_signal = boost::make_shared<Signal>();
        }

        ~SelfReference()
        {
                // the first slot (ReleaseSelf) has been called; now the trackable object (this)
                // was released, while the second slot is locked
                assert(!m_conReleaseSelf.connected());
                // the second slot is locked, and we enter a recursive (pthread: dead) lock
                assert(m_conDoNothing.connected());
                m_conReleaseSelf.disconnect();
                m_conDoNothing.disconnect();
                // enter recursive (pthread: dead) lock again:
                assert(m_signal->empty());
        }

        void ReleaseSelf()
        {
                m_self.reset();
        }

        static void DoNothing()
        {
        }

        static void Run()
        {
                boost::shared_ptr<Signal> signal;
                {
                        boost::shared_ptr<SelfReference> obj = boost::make_shared<SelfReference>();
                        obj->m_self = obj;
                        signal = obj->m_signal;

                        obj->m_conReleaseSelf = signal->connect(Signal::slot_type(&SelfReference::ReleaseSelf, obj.get()).track(obj));
                        obj->m_conDoNothing = signal->connect(Signal::slot_type(&SelfReference::DoNothing));
                }
                (*signal)();
        }
};

int main() {
        SelfReference::Run();

        return 0;
}