C++中vector多线程操作

2017.02.14

有一个全局变量 vector goods_list;

在A线程中从服务器获取最新商品列表，goods_list.push_back()

在B线程中不断的下载商品图片，
Goods &goods = goods_list.at(i)
读取goods .pic_url，下载完成后赋值 goods.local_pic = local_pic

以上简单的逻辑，缺导致程序崩溃，提示内存写入错误。

调试定位到goods.local_pic = local_pic这一句。

估计就是多线程的问题。
查了一下资料，原来vector每次push_back都会重新分配内存，导致goods 这个引用无效，所以goods.local_pic = local_pic赋值写入的时候就会写入到一个无效的地址，导致程序崩溃。

解决办法：
在构造函数中提前对goods_list.reserve(30000)分配足够的固定内存，这样就不用每次pushback都申请增加内存、重新分配内存 导致的原内存地址无效，而且效率也高很多。

相关资料：
对于vector和string，如果需要更多空间，就以类似realloc的思想来增长大小。这个类似于realloc的操作有四个部分：
分配新的内存块，它有容器目前容量的倍数。在大部分实现中，vector和string的容量每次以2为因数增长。也就是说，当容器必须扩展时，它们的容量每次翻倍。
把所有元素从容器的旧内存拷贝到它的新内存。
销毁旧内存中的对象。
回收旧内存。

给了所有的分配，回收，拷贝和析构，你就应该知道那些步骤都很昂贵。当然，你不会想要比必须的更为频繁地执行它们。如果这没有给你打击，那么也许当你想到每次这些步骤发生时，所有指向vector或string中的迭代器、指针和引用都会失效时，它会给你打击的。这意味着简单地把一个元素插入vector或string的动作需要更新其他使用了指向vector或string中的迭代器、指针或引用的数据结构
reserve成员函数允许你最小化必须进行的重新分配的次数，因而可以避免真分配的开销和迭代器/指针/引用失效。但在我解释reserve为什么可以那么做之前，让我简要介绍有时候令人困惑的四个相关成员函数。在标准容器中，只有vector和string提供了所有这些函数。

==============
2017年12月14日更新
vector预先分配内存只适用于一些稳定成员变量或者全局变量，不会出现各种new父类的情况。
例如下面这种情况，就不适合预先分配：
做了一个消息池类MsgPool（对应一个群消息），内部成员vector text_list（对应该群每条消息），同时可能几百个群，需要声明几百个对象，也就是几百个MsgPool，每个MsgPool再预先为内部的vector分配内存，这样就是几百乘以几万，几千万的预分配，这时候预先分配空间就极大的占用了内存，甚至一度导致占用内存1.5G，从而程序崩溃。
真正解决vector多线程的问题还是应该使用同步锁，然后封装好对vector的操作，每次写入前都锁住，执行完毕本次写入后，其他线程需要写入才能进去，这样就不会出现内存被重新分配同时也在写入导致内存无效了。

比如下面我的MsgPool类：

CMassMsgPool::CMassMsgPool(){
    InitializeCriticalSection(&cs_write);

}

CMassMsgPool::~CMassMsgPool()
{ 
    DeleteCriticalSection(&cs_write); 
}


//添加一个
bool CMassMsgPool::Add(MassMsg msg, int insert_mode){

    EnterCriticalSection(&cs_write);

    if (msg.type == 0)
        msg.type = MMT_NORMAL;


    //产生一个唯一KEY，用来识别
    if (msg.key == 0)
        msg.key = GetTickCount() % 999999 + msg.title.length() + rand();
    //发送状态为0
    msg.send_status.code = SS_NEW;


    switch (insert_mode){
    case INSERT_FIRST:
        msg_list_.insert(msg_list_.begin(), msg); break;
    case INSERT_END:
        msg_list_.push_back(msg); break;
    case INSERT_RANDOM:
        msg_list_.insert(msg_list_.begin() + rand() % (msg_list_.size() + 1), msg); break;
    default:
        msg_list_.push_back(msg); break;
    }



    LeaveCriticalSection(&cs_write);

    return true;
}
//根据key查找信息，并设置信息
int CMassMsgPool::UpdateMsg(long key, MassMsg &msg){

    EnterCriticalSection(&cs_write);

    int index = -1;
    for (int i = 0; i < msg_list_.size(); i++){
        MassMsg &dst_msg = msg_list_.at(i);
        //key一样
        if (dst_msg.key == key){
            if (index == -1) index = i;
            //直接覆盖
            dst_msg = msg;

            //无需break，因为偶尔有key会重复，需要全部更新状态，否则重复的key永远无法更新状态
            //break;
        }
    }

    LeaveCriticalSection(&cs_write);

    return index;
}


void CMassMsgPool::UpdateMsgAt(int index, MassMsg &msg){
    EnterCriticalSection(&cs_write);
    msg_list_.at(index) = msg;
    LeaveCriticalSection(&cs_write);
}

/根据key查找信息 并删除

void CMassMsgPool::RemoveMsg(long key){
    EnterCriticalSection(&cs_write);

    for (int i = 0; i < msg_list_.size(); i++){
        if (msg_list_.at(i).key == key)
        {
            msg_list_.erase(msg_list_.begin() + i);
        }

    }
    LeaveCriticalSection(&cs_write);
    return;
}

void CMassMsgPool::RemoveMsgAt(int index){
    EnterCriticalSection(&cs_write);
    msg_list_.erase(msg_list_.begin() + index);
    LeaveCriticalSection(&cs_write);
    return;
}

void CMassMsgPool::RemoveAll(){
    EnterCriticalSection(&cs_write);
    msg_list_.clear();
    LeaveCriticalSection(&cs_write);
}


void CMassMsgPool::MoveMsgToRow(int index, int new_pos){
    EnterCriticalSection(&cs_write);
    MassMsg msg = msg_list_.at(index);
    //删除
    msg_list_.erase(msg_list_.begin() + index);
    //然后插入
    msg_list_.insert(msg_list_.begin() + new_pos, msg);

    LeaveCriticalSection(&cs_write);
}

long CMassMsgPool::GetKey(int index){
    return msg_list_.at(index).key;
}

这样就没任何问题