Hi All,
I've just realized weak_ptr::lock is not thread safe. Is it expected
behavior? Following sample reproduced this conclusion.
#include <iostream>
#include
#include
#include
#include
#include
static volatile int v = 0;
boost::interprocess::interprocess_semaphore s1(0);
boost::interprocess::interprocess_semaphore s2(0);
boost::interprocess::interprocess_semaphore s3(0);
class SomeClass{
public:
boost::shared_ptr<SomeClass> s_this_;
boost::weak_ptr<SomeClass> w_this_;
SomeClass()
{
s_this_.reset( this );
w_this_ = s_this_;
v = 1;
}
void release()
{
s_this_.reset();
}
~SomeClass()
{
v = 0;
}
};
SomeClass *c;
void worker()
{
int counter = 0;
for( ;; )
{
s1.wait(); // wait for created
object
boost::weak_ptr<SomeClass> w = c->w_this_; // make weak ptr
s2.post(); // let main thread
go ahead
boost::shared_ptr<SomeClass> s = w.lock(); // create shared_ptr
from weak_ptr
if( s ) // test for valid
shared_ptr
{
if( 0 == v ) // if 0, object is
destroyed
{
std::cout << "!!!!!!!! : " << counter << std::endl;
exit(1);
}
}
s3.post(); // notify main
thread about test completion
++counter;
}
}
int main()
{
boost::thread t = boost::thread( &worker );
for( ;; )
{
c = new SomeClass(); // create object
s1.post(); // notify thread about new object
s2.wait(); // wait for thread to make weak_ptr
c->release(); // destroy object
s3.wait(); // wait for thread complete
}
return 0;
}
Best regards.
Dima
--
Dmytro Ovdiienko
