在std :: thread中使用std :: vector

nnrales 发表于 Dev

nnrales

我有一个程序，可以在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 ; 
}

塞弗林·帕帕德（Severin Pappadeux）

在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/

本文收集自互联网，转载请注明来源。

如有侵权，请联系[email protected] 删除。