小编hop*_*pla的帖子

我想知道下面的代码是否会被认为是线程安全的.我认为它应该是,但我不太熟悉引擎盖下发生的事情.

基本上,我在类Foo中有这个函数,它将在主线程上调用并将一个向量作为一个anrgument,即

void Foo::func( vector<int> v)

在Foo,我也有一个私人会员,

vector< vector<int> > vecOfVec;

内func,我会简单地推回任何新v上vecOfVec和检查v的规模.如果v小于其预期的大小,我想开始另一个填充了v一些已知的预定值的线程,如此

void Foo::func( vector<int> v)
{
    int size = v.size();
    int index = vecOfVec.size();

    vecOfVec.push_back(v);

    if (size < 1000)
    {
        boost::thread t( boost::bind( &Foo::PushBackZeros, this, vecOfVec, index) );
    }
}

Foo::PushBackZeros 就像它的名字所暗示的那样,用'零填充'vecOfVec [index]'的向量,直到它的大小增加到1000;

现在,我没有在任何元素上看到任何并发读或写操作vecOfVec.显然,有可能对整个对象进行并发操作,但永远不会有特定元素的并发vecOfVec.

有人可以解释上述是否会被认为是线程安全的吗？STL地图也同样程度吗？如果没有,请解释.干杯!

我需要澄清一个我不太了解的问题.使用下面的两个场景,我会认为分配的内存量大致相同.但是,方案2 bad_alloc在一段时间后给了我一个例外,并且似乎像疯了一样咀嚼内存(使用Window的任务管理器作为分配给进程的内存量的代理).以下是使用MSVC10在Windows 32位上编译的.

假设我有以下基类:

template<class T>
class Base
{
protected:
    T x;
public:
    Base() {}
    Base(T _x) : x(_x){}
    virtual bool func() = 0;
};

现在,至于派生类:

template<class T>
class Derived : public Base<T>
{
public:
    Derived() {}
    Derived(T _x) :  Base(_x){}
    bool func() { return true; };
};

现在考虑两种情况.首先,分配Derived类的动态数组并用Derived对象填充它,即:

int main()
{
    int size = SOME_LARGE_NUMBER;
    Derived<int>* d = new Derived<int>[size];
    for (int i = 0; i < size; i++)
    {
        d[i] = Derived<int>(i);
    }

    // delete here
} …