Question

我有一个程序，我在std :: vector中浏览每个类，对它执行一些操作并将其写入新的std :: vector

在我的程序中，std :: vector很大，在类上完成的操作非常耗时。所以我想知道我是否可以使用std :: thread将std :: vector上的操作分解为块。我的意思是

============================== std::vector
^ Processing by a single thread 

==========  ==========  ==========  
^ thread 1  ^ thread 2   ^ thread 3

理想情况下，我会让线程1从1到10,000元素的线程2通过下一个元素块。

最后，我希望输出存在于单个向量中。所以我不必创建多个std :: vectors并加入它。

如果它有帮助我正在创建类似神经网络的东西。虽然不太喜欢它，但我不能使用它的流行实现。

我尝试了什么:(来自下面的建议）

class obj_thread {
private:
    std::mutex m_mutex; 
    std::vector<int> *_data ; 
public: 
    obj_thread(int _size = 0 )
    {
        _data = new std::vector<int>(0); 
        for(int elem_ = 0 ; elem_ < _size ; ++elem_)
            _data->push_back(elem_ * 9);
    }
    ~obj_thread()
    {
        delete _data; 
    }   
    void setElemAt(int _val , int _elem) 
    {
        std::lock_guard<std::mutex> locker(m_mutex);
            _data->at(_elem) = _val;
    };
    int getElem(int _elem) const { return _data->at(_elem);}
    int getSize() const 
    {
    //  std::lock_guard<std::mutex> locker(m_mutex);
        return _data->size();
    };
};

void zeroOut(std::vector<obj_thread*> * _obj , int _beg , int _end)
{
    for(int idx_ = _beg ; idx_ < _end ; ++idx_)
    {
        for(int idxx_ = 0 ; idxx_ < _obj->at(idx_)->getSize() ; ++idxx_)    
            _obj->at(idx_)->setElemAt(0,idxx_);
    }   
}



int main() {

std::vector<obj_thread*> * vec = new std::vector<obj_thread*>(0);
for(unsigned int index_ = 0 ; index_ < _SIZE_ ; ++index_)   
    vec->push_back(new obj_thread(_SIZE_));


    std::thread thread1(zeroOut,vec,_SIZE_/4,_SIZE_/2);
    std::thread thread2(zeroOut,vec,_SIZE_/2,_SIZE_*3/4);
    std::thread thread3(zeroOut,vec,_SIZE_*3/4,_SIZE_);

    thread1.join();
    thread2.join();
    thread3.join();

return 0 ; 
}

Answer 1

在std :: copy之后为您的操作建模。

沿线的东西

#include <thread>

std::vector<int> in; // make whatever size you want
std::vector<int> out;

auto m_in  = in.cbegin() + in.size()/2;
auto m_out = out.begin() + in.size()/2;

std::thread t1(std::copy, in.cbegin(), m_in, out.begin());
std::thread t2(std::copy, m_in, in.cend(), m_out);

t1.join();
t2.join();

这应该会在一个线程中复制一半的传入数组，而在另一个线程中复制另一半。未经测试！

如果这是您想要的，现在您必须编写类似于std :: copy的函数，只需用您的域特定处理替换赋值

http://www.cplusplus.com/reference/algorithm/copy/

使用std :: vector和std :: thread

1 个答案: