pure virtual method called(__cxa_pure_virtual)崩溃

纯虚函数，在子类中实现，在父类中某个线程调用，线程的调用的结束在父类的析构函数中;
导致__cxa_pure_virtual崩溃pure virtual method called

直接上demo代码，详见父类A的purefunc

/*
 * 纯虚函数，在子类中实现，在父类中某个线程调用，
 * 线程的调用的结束在父类的析构函数中;
 * 导致__cxa_pure_virtual崩溃pure virtual method called
 * #0  0x00007fc689aa5387 in raise () from /lib64/libc.so.6
 * #1  0x00007fc689aa6a78 in abort () from /lib64/libc.so.6
 * #2  0x00007fc68ff9a7d5 in __gnu_cxx::__verbose_terminate_handler() () from /lib64/libstdc .so.6
 * #3  0x00007fc68ff98746 in ?? () from /lib64/libstdc .so.6
 * #4  0x00007fc68ff98773 in std::terminate() () from /lib64/libstdc .so.6
 * #5  0x00007fc68ff992df in __cxa_pure_virtual () from /lib64/libstdc .so.6
 */

#include <stdlib.h>
#include <stdio.h>
#include <thread>

class A
{
public:
    A() : bThreadRunning(false) 
    {}

    virtual ~A()
    {
        fprintf(stderr, "dtor A start.\n");
        std::this_thread::sleep_for(std::chrono::seconds(2));

        fprintf(stderr, "dtor A freeing thread.\n");
        bThreadRunning = false;
        if (pt)
        {
            if (pt->joinable())
            {
                pt->join();
                delete pt;
                pt = NULL;
            }
        }
    }

    virtual void purefunc() = 0;
    // {
    //     fprintf(stderr, "A purefunc.\n");    // 避免崩溃的方式，就是在父类中进行默认的实现。当子类析构了，执行父类的实现
    // }

    void start()
    {
        bThreadRunning = true;
        pt = new std::thread(std::bind(&A::threadrun, this));
        if (pt)
            fprintf(stderr, "start thread success.\n");
    }

private:
    void threadrun()
    {
        int i = 0;
        while(bThreadRunning)
        {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            fprintf(stderr, "sub-thread sleep %d seconds\n", ++i);
            purefunc();
        }
    }

private:
    bool bThreadRunning;
    std::thread *pt;
};


class B : public A
{
public:
    B() = default;
    virtual ~B(){
        fprintf(stderr, "dtor B.\n");
    }

    virtual void purefunc()
    {
        fprintf(stderr, "purefunc B.\n");
    }
};

int main()
{
    B *b = new B();
    b->start();

    for(int i = 0; i < 10; i++)
    {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        fprintf(stderr, "main thread sleep %d seconds\n", i);
    }

    delete b;

    return 0;
}