用多个线程填充 unique_ptr 的向量?
Filling a vector of unique_ptr with multiple threads?
我有一个 class,给定一个设备 ID,它会初始化该设备。 class 的析构函数再次关闭设备。
因为我有多个这样的设备连接到我的系统,所以我写了一个枚举器 class 来初始化每个连接的设备。由于 device
的析构函数释放了设备的资源,我使用了 unique_ptr< device >
所以没有无意中复制/删除 device
对象。
struct device_id {
// information to identify device
}
class device {
public:
device( device_id const & id ) {
// initialize device
}
void act() {
// use the device
}
~device() {
// spool down device
}
};
class device_enumerator {
public:
device_enumerator( std::vector< device_id > const & ids ) {
for ( auto const & id : ids ) {
devices.push_back( std::unique_ptr< device >( new device( id ) ) );
}
}
typedef std::vector< std::unique_ptr< device > > device_vector;
device_vector::iterator begin() { return devices.begin(); }
device_vector::iterator end() { return devices.end(); }
private:
device_vector devices;
};
由于每个设备都需要一些时间来缓冲,因此按顺序初始化所有设备是一个漫长的过程。所以我想并行化设备初始化(因为设备构造函数基本上处于空闲状态,直到设备返回信号)。
但是——这是我第一次尝试使用 <thread>
——我不知道如何从 std::thread
中检索 std::unique_ptr< device >
对于每个设备,然后以任何优雅的方式再次加入线程。 (如果 std::thread
在这里确实是正确的...)
我如何并行化这个:
for ( auto const & id : ids ) {
devices.push_back( std::unique_ptr< device >( new device( id ) ) );
}
由于初始化每个设备是独立的任务,因此 std::async 在这里更有意义,实现此目的的示例代码如下:
void init(std::unique_ptr<device>& p)
{
p.reset(new device(device_id())); //time consuming operation
}
int main() {
//8 number of elements in vector are for demo purpose only
std::vector<std::unique_ptr<device>> vecOfDevices(8);
std::vector<std::future<void>> vecOfFutures(8);
int index = 0;
for(auto& elem:vecOfDevices)
{
//async launch policy will construct each in seperate thread
vecOfFutures[index] = std::async(std::launch::async,init,std::ref(vecOfDevices[index]));
index++;
}
//Do some other operations here
for(auto& elem:vecOfFutures)
{
elem.wait(); //wait so that all devices got initialized
}
//start using your devices from here
vecOfDevices[0]->act();
return 0;
}
我有一个 class,给定一个设备 ID,它会初始化该设备。 class 的析构函数再次关闭设备。
因为我有多个这样的设备连接到我的系统,所以我写了一个枚举器 class 来初始化每个连接的设备。由于 device
的析构函数释放了设备的资源,我使用了 unique_ptr< device >
所以没有无意中复制/删除 device
对象。
struct device_id {
// information to identify device
}
class device {
public:
device( device_id const & id ) {
// initialize device
}
void act() {
// use the device
}
~device() {
// spool down device
}
};
class device_enumerator {
public:
device_enumerator( std::vector< device_id > const & ids ) {
for ( auto const & id : ids ) {
devices.push_back( std::unique_ptr< device >( new device( id ) ) );
}
}
typedef std::vector< std::unique_ptr< device > > device_vector;
device_vector::iterator begin() { return devices.begin(); }
device_vector::iterator end() { return devices.end(); }
private:
device_vector devices;
};
由于每个设备都需要一些时间来缓冲,因此按顺序初始化所有设备是一个漫长的过程。所以我想并行化设备初始化(因为设备构造函数基本上处于空闲状态,直到设备返回信号)。
但是——这是我第一次尝试使用 <thread>
——我不知道如何从 std::thread
中检索 std::unique_ptr< device >
对于每个设备,然后以任何优雅的方式再次加入线程。 (如果 std::thread
在这里确实是正确的...)
我如何并行化这个:
for ( auto const & id : ids ) {
devices.push_back( std::unique_ptr< device >( new device( id ) ) );
}
由于初始化每个设备是独立的任务,因此 std::async 在这里更有意义,实现此目的的示例代码如下:
void init(std::unique_ptr<device>& p)
{
p.reset(new device(device_id())); //time consuming operation
}
int main() {
//8 number of elements in vector are for demo purpose only
std::vector<std::unique_ptr<device>> vecOfDevices(8);
std::vector<std::future<void>> vecOfFutures(8);
int index = 0;
for(auto& elem:vecOfDevices)
{
//async launch policy will construct each in seperate thread
vecOfFutures[index] = std::async(std::launch::async,init,std::ref(vecOfDevices[index]));
index++;
}
//Do some other operations here
for(auto& elem:vecOfFutures)
{
elem.wait(); //wait so that all devices got initialized
}
//start using your devices from here
vecOfDevices[0]->act();
return 0;
}