boost::thread 和包含类的析构函数

Question

我想了解这段代码的行为。

class Foo
{
      public:
            Foo();
            ~Foo();
            void run();
            int* get();
    private:
            int *a;
};

Foo::Foo()
{
     a=NULL;       
}
void Foo::run()
{
       if ( a==NULL)
            a = new int[30000];
}

int* Foo::get()
{
    return a;
}

Foo::~Foo()
{
    cout << "destructor called" << endl;
    if ( a!=NULL)
            delete a;
}

int main()
{
        Foo *a = new Foo();

        boost::thread Foothread( &Foo::run, a);
        // Some very long computation that sometimes access 

        int *b  = a->get();
        cout << *b << endl; 
        //Foothread.join();
        //delete a;
        //Foothread.join();

        return 0;
}

此代码导致 120000 字节的内存泄漏，因为变量 a 没有被破坏，所以当我明确删除它时，泄漏消失了，一切都应该没问题。

现在如果我不是动态分配a，而是使用静态分配，析构函数会被多次调用！！！

int main()
{
        Foo a;

        boost::thread Foothread( &Foo::run, a);
        // Some very long computation that sometimes access "a"
        Foothread.join();
        int *b  = a.get();
        cout << *b << endl; 

        return 0;
}

输出是 调用析构函数，a 为 0 现在 a 为 0 调用析构函数，a 为 0 现在 a 为 0 调用析构函数，a 为 0 现在 a 为 0 调用析构函数，a 为 0 现在 a 为 0 调用析构函数，a 为 0 现在 a 为 0 调用析构函数，a 为 0 现在 a 为 0 调用析构函数，a 为 0x75e300 现在 a 为 0 分段错误

析构函数被调用了N次！！

现在我想知道如何使用 boost::thread 安全地分配和解除分配类成员变量和对象，以及为什么线程析构函数不显式处理类析构函数。

有人可以给我一个提示吗？ boost::smart_ptr 应该帮助我吗？我必须用 malloc 分配内存（因为我需要使用一些旧的 C API），我怎样才能做到线程安全？

Answer 1

两个版本都在线程 1 中创建类 Foo 的对象，并从后台线程（线程 2）调用其 run 方法。当run 返回时，该后台线程终止。

run实际上是初始化类Foo的对象。您的代码中的一个问题是，您可能会进行一些非常长的计算，这些计算有时会在线程 1 中访问“a”在线程 2 完成 a 的初始化之前。这会导致竞争条件。为避免这种情况，您应该在访问a 中的Foo::a 之前调用Foothread.join()。

其他几点：

• 在 Foo::~Foo() 中，您不需要检查要删除的指针是否与 NULL 不同
• 使用new 创建的数组a 必须使用delete[] a; 删除

Answer 2

第二种情况应该是&a吗？

boost::thread Foothread( &Foo::run, &a);