Race-Bedingung in pthread_once ()?
Ich habe einstd::future
in einem Thread, der auf einen wartetstd::promise
in einem anderen Thread gesetzt.
BEARBEITEN: Die Frage wurde mit einer beispielhaften App aktualisiert, die für immer blockiert:
AKTUALISIEREN: Wenn ich a benutzepthread_barrier
Stattdessen wird der folgende Code verwendetnicht Block.
Ich habe eine Test-App erstellt, die dies veranschaulicht:
Im Grunde genommen klassefoo
schafft einethread
was setzt einpromise
in seiner run-Funktion und wartet im Konstruktor daraufpromise
gesetzt werden. Einmal eingestellt, erhöht es einatomic
Anzahl
Ich erstelle dann einen Haufen davonfoo
Gegenstände, reißen sie nieder, und überprüfen Sie meinecount
.
#include <iostream>
#include <thread>
#include <atomic>
#include <future>
#include <list>
#include <unistd.h>
struct foo
{
foo(std::atomic<int>& count)
: _stop(false)
{
std::promise<void> p;
std::future <void> f = p.get_future();
_thread = std::move(std::thread(std::bind(&foo::run, this, std::ref(p))));
// block caller until my thread has started
f.wait();
++count; // my thread has started, increment the count
}
void run(std::promise<void>& p)
{
p.set_value(); // thread has started, wake up the future
while (!_stop)
sleep(1);
}
std::thread _thread;
bool _stop;
};
int main(int argc, char* argv[])
{
if (argc != 2)
{
std::cerr << "usage: " << argv[0] << " num_threads" << std::endl;
return 1;
}
int num_threads = atoi(argv[1]);
std::list<foo*> threads;
std::atomic<int> count(0); // count will be inc'd once per thread
std::cout << "creating threads" << std::endl;
for (int i = 0; i < num_threads; ++i)
threads.push_back(new foo(count));
std::cout << "stopping threads" << std::endl;
for (auto f : threads)
f->_stop = true;
std::cout << "joining threads" << std::endl;
for (auto f : threads)
{
if (f->_thread.joinable())
f->_thread.join();
}
std::cout << "count=" << count << (num_threads == count ? " pass" : " fail!") << std::endl;
return (num_threads == count);
}
Wenn ich dies in einer Schleife mit 1000 Threads laufen lasse, muss es nur einige Male ausgeführt werden, bis ein Rennen stattfindet und einer derfutures
wird nie geweckt, und deshalb bleibt die App für immer hängen.
# this loop never completes
$ for i in {1..1000}; do ./a.out 1000; done
Wenn ich jetztSIGABRT
In der App zeigt der resultierende Stack-Trace, dass er auf dem Computer stecktfuture::wait
Der Stack-Trace ist unten:
// main thread
pthread_cond_wait@@GLIBC_2.3.2 () from /lib64/libpthread.so.0
__gthread_cond_wait (__mutex=<optimized out>, __cond=<optimized out>) at libstdc++-v3/include/x86_64-unknown-linux-gnu/bits/gthr-default.h:846
std::condition_variable::wait (this=<optimized out>, __lock=...) at ../../../../libstdc++-v3/src/condition_variable.cc:56
std::condition_variable::wait<std::__future_base::_State_base::wait()::{lambda()#1}>(std::unique_lock<std::mutex>&, std::__future_base::_State_base::wait()::{lambda()#1}) (this=0x93a050, __lock=..., __p=...) at include/c++/4.7.0/condition_variable:93
std::__future_base::_State_base::wait (this=0x93a018) at include/c++/4.7.0/future:331
std::__basic_future<void>::wait (this=0x7fff32587870) at include/c++/4.7.0/future:576
foo::foo (this=0x938320, count=...) at main.cpp:18
main (argc=2, argv=0x7fff32587aa8) at main.cpp:52
// foo thread
pthread_once () from /lib64/libpthread.so.0
__gthread_once (__once=0x93a084, __func=0x4378a0 <__once_proxy@plt>) at gthr-default.h:718
std::call_once<void (std::__future_base::_State_base::*)(std::function<std::unique_ptr<std::__future_base::_Result_base, std::__future_base::_Result_base::_Deleter> ()>&, bool&), std::__future_base::_State_base* const, std::reference_wrapper<std::function<std::unique_ptr<std::__future_base::_Result_base, std::__future_base::_Result_base::_Deleter> ()> >, std::reference_wrapper<bool> >(std::once_flag&, void (std::__future_base::_State_base::*&&)(std::function<std::unique_ptr<std::__future_base::_Result_base, ...) at include/c++/4.7.0/mutex:819
std::promise<void>::set_value (this=0x7fff32587880) at include/c++/4.7.0/future:1206
foo::run (this=0x938320, p=...) at main.cpp:26
Ich bin mir ziemlich sicher, dass ich in meinem Code nichts falsch mache, oder?
Ist dies ein Problem mit der Implementierung von pthread oder der Implementierung von std :: future / std :: promise?
Meine Bibliotheksversionen sind:
libstdc++.so.6
libc.so.6 (GNU C Library stable release version 2.11.1 (20100118))
libpthread.so.0 (Native POSIX Threads Library by Ulrich Drepper et al Copyright (C) 2006)