[Boost-users] shared_ptr and thread safety

From: gast128 (gast128_at_[hidden])
Date: 2007-08-06 08:51:21

Dear all,

it is already posted a dozen times, but still I do not get it. I understand 
that if you have a class, the shared_ptr will not make this thread safe. 
That's fair. Non const operations accessed by different threads should still 
be guarded (and probably their const versions then also). 

But what about the shared_ptr itself. From the doc's 
(http://www.boost.org/libs/smart_ptr/shared_ptr.htm#ThreadSafety) I read that 
reading and writing to the shared_ptr object (not the pointee) is safe: 

'A shared_ptr instance can be "read" (accessed using only const operations) 
simultaneously by multiple threads. Different shared_ptr instances can 
be "written to" (accessed using mutable operations such as operator= or reset) 
simultaneosly by multiple threads (even when these instances are copies, and 
share the same reference count underneath.)'

However then a couple of examples are listed where both operator= and a dtor 
call are marked as undefined, and this is of course the most use (share a 
shared pointer over multiple threads and let them decide who finishes last, 
but this is then illegal?)

>From the code I see that the ref counting is implemented through atomic inc's 
and dec's, and I would therefore expect that it is thread safe after all, 
since only the thread which makes the ref count 0 will be assigned the job 
of 'dispose', and the ref counting is thread safe.

who can help this poor programmer...

wkr,
me