如果我不加入发布版本中“破坏”的线程呢?

在许多情况下,我有一些类的行为类似于活动对象(有一个线程)。为了避免访问冲突,我总是要等待加入析构函数。这通常不是问题。

然而,想象一个版本构建中有一些bug(死锁、LiveLock等)会导致 join() 不按时或根本不返回,这将导致整个应用程序在等待不再使用的对象时变得不起作用。如果这种情况发生在客户身上,就会成为一个问题。

我宁愿被这个问题通知并跳过加入。泄漏线程和它的资源。

跳过连接可以通过这样的方式实现。

   class MyActiveObject
    {
    public:
        MyActiveObject();
        ~MyActiveObject(){}
    private
        struct Implementation;
        std::shared_ptr<Implementation> pImpl_;
    };

    struct MyActiveObject::Implementation : std::enable_shared_from_this<Implementation >
    {
        Implementation() : thread_([=]{Run();})
        {
        }

        ~Implementation()
        {
            #ifdef _DEBUG
                thread_.join();
            #else
                if(!thread_.timed_join(SOME_TIMEOUT))
                    ALERT_SOME_HOW();
            #endif
        }

        void Dispose()
        {
            isRunning_ = false;
        }

        void Run()
        {
        #ifndef _DEBUG
            auto pKeepAlive = shared_from_this(); // Won't be destroyed until thread finishes
        #endif   
            isRunning_ = true;
            while(isRunning_)
            {
                 /* ... */
            }
        }

        boost::thread thread_;
        tbb::atomic<bool> isRunning_;
    };

MyActiveObject::MyActiveObject() : pImpl_(new Implementation()){}
MyActiveObject::~MyActiveObject() { pImpl_->Dispose(); }

这是个好主意吗?还是有更好的策略?