C++ std::vector d'indépendant std::threads

/usr/local/include/c++/5.1.0/ext/new_allocator.h: In instantiation of 'void __gnu_cxx::new_allocator<_Tp>::construct(_Up*, _Args&& ...) [with _Up = std::thread; _Args = {const std::thread&}; _Tp = std::thread]':
/usr/local/include/c++/5.1.0/bits/alloc_traits.h:256:4:   required from 'static std::_Require<std::allocator_traits<_Alloc>::__has_construct<_Tp, _Args ...> > std::allocator_traits<_Alloc>::_S_construct(_Alloc&, _Tp*, _Args&& ...) [with _Tp = std::thread; _Args = {const std::thread&}; _Alloc = std::allocator<std::thread>; std::_Require<std::allocator_traits<_Alloc>::__has_construct<_Tp, _Args ...> > = void]'
/usr/local/include/c++/5.1.0/bits/alloc_traits.h:402:16:   required from 'static decltype (_S_construct(__a, __p, (forward<_Args>)(std::allocator_traits::construct::__args)...)) std::allocator_traits<_Alloc>::construct(_Alloc&, _Tp*, _Args&& ...) [with _Tp = std::thread; _Args = {const std::thread&}; _Alloc = std::allocator<std::thread>; decltype (_S_construct(__a, __p, (forward<_Args>)(std::allocator_traits::construct::__args)...)) = <type error>]'
/usr/local/include/c++/5.1.0/bits/stl_vector.h:917:30:   required from 'void std::vector<_Tp, _Alloc>::push_back(const value_type&) [with _Tp = std::thread; _Alloc = std::allocator<std::thread>; std::vector<_Tp, _Alloc>::value_type = std::thread]'
main.cpp:37:30:   required from here
/usr/local/include/c++/5.1.0/ext/new_allocator.h:120:4: error: use of deleted function 'std::thread::thread(const std::thread&)'
{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }

Permet de pellicule un peu.

error: use of deleted function 'std::thread::thread(const std::thread&)'

Votre code est en train de faire quelque chose que les tentatives d'introduire une std::thread.

required from 'void std::vector<_Tp, _Alloc>::push_back(const value_type&)

push_back est le coupable.

std::thread n'est pas copiable - qu'en serait-il dire pour copier un thread?

std::thread t1([](){});
std::thread t2 = t1;

Ainsi les instances de std::thread objets sont destinés à être uniques propriétaires. En dehors de la simple confusion, beaucoup de douleur s'ensuivrait.

Ils sont, toutefois, des biens meubles.

std::thread t1([](){});
std::thread t2 = std::move(t1);

t1 n'est plus valide fil descripteur, le thread qu'il a été décrit est maintenant détenue par t2.

Pour placer de telles choses dans un conteneur, vous pouvez soit utiliser std::move ou std::emplace/std::emplace_back.

std::vector<std::thread> threads;
threads.push_back(std::move(std::thread([](){})));
threads.emplace_back([](){});

Alors que votre code est de mettre l'accent sur cette question en particulier, permettez-moi de souligner que la norme C++ déclare qu'il y a comme une erreur pour un thread destructeur à être invoquée en tant qu'un thread est encore attaché et n'a pas adhéré.

int main() {
std::thread t1([](){ while (true) { std::this_thread::yield(); } };
}

Lorsque principale se termine, t1.~thread() est appelée, qui détecte que le thread est toujours attaché et n'a pas adhéré, ce qui soulève une exception provoque un arrêt de l'accident.

Vous avez besoin soit de join() le fil, en attente pour elle de résilier en cours d'exécution, ou detach(). Vous aurez besoin d'une façon de dire que le thread de s'arrêter si vous souhaitez utiliser join() et si vous detach() le programme peut sortir dans le milieu de la thread de faire quelque chose comme de l'écriture de données, etc, vous pouvez introduire un bug grave.

#include <thread>
#include <chrono>
#include <future>
int main () {
std::promise<void> cnx_promise;
std::shared_future<void> cnx_future;
std::thread t1([cnx_future]() {
while (cnx_future.valid()) {
std::this_thread::yield();
}
});
std::this_thread::sleep_for(std::chrono::seconds(1));
cnx_promise.set_value();
t1.join();
}

Ici, nous utilisons une promesse de laisser le fil de savoir quand il est temps d'arrêter de courir, mais vous pouvez utiliser les variables de condition, signaux, etc, ou même juste une simple std::atomic<bool> ok_to_run { true }; test pour de faux.

OriginalL'auteur kfsone

C'est la garantie que chaque thread va être créé dans le vecteur de stockage. Aucun objet d'octets à copier.

for (int &reader : readers)
readerThreads.emplace_back( readerThread::start, reader );

Dans le cas de ce pas la même chose que @Seth suggéré. Mais dans le cas actuel, il est à 99% le même.

OriginalL'auteur kyb