Boost logo

Boost :

From: Lance.Diduck_at_[hidden]
Date: 2008-04-21 13:35:26

> I thought boost::shared_ptr was lock-free and thread safe on the major
platforms supported by boost. I could > be wrong though.

The reference counter is lock-free and thread safe. The shared_ptr
itself is not

shared_ptr<A> mutualA(new A);
mutex mutualAlock;
void * thread_func(void*){
    shared_ptr<A> isolatedA;
         //accessing mutualA requires lock
    //accessing isolatedA is fine
    //this only depends on the ref counter being thread safe
    vector<shared_ptr<A> > vA(100,isolatedA);

Also, it should be clear that this is unsafe:

void * thread_func2(void*){
Since another thread is likely to do
void * thread_func3(void*){
        mutualA.reset(new A);//oops just deleted object thread_func2 was

In the pointer I have, the above code would be
linear_mutual_ptr<A> mutualA(new A); //for the shared instance
void * thread_func_l(void*){
    linear_ptr<A> isolatedA=mutualA;//for the isolated instance
    //isolatedA now has a copy, access like shared_ptr sans weak_ptr
    vector<linear_ptr<A> > vA(100,linearA);
//and FWIW this works
    vector<linear_mutual_ptr<A> > vAm(100,mutualA);
//but copies of linear_mutual_ptr are not as efficient
//AND of course not every element may actually
//points to the same object
void * thread_func2_l(void*){
//ensure that the object is going to hang around long enough
//to complete the operation

linear_mutual_ptr also has a
bool compare_and_swap(linear_ptr<T> const &oldval, linear_ptr<T> const
Operation, so that simple STM systems can be built using it, i.e.

void * thread_func_l2(void*){
    linear_ptr<A> isolatedA=mutualA;
    linear_ptr<A> isolatedA2(new A(*isolatedA));
    //not shown, but A's operator new has a lock-free allocator attached
    if(mutualA.compare_and_swap(isolatedA,isolatedA2))return 0;


-----Original Message-----
From: boost-bounces_at_[hidden]
[mailto:boost-bounces_at_[hidden]] On Behalf Of Patrick Twohig
Sent: Monday, April 21, 2008 12:37 PM
To: boost_at_[hidden]
Subject: Re: [boost] Nonlocking data structures.

I thought boost::shared_ptr was lock-free and thread safe on the major
platforms supported by boost. I could be wrong though.
Unsubscribe & other changes:
Visit our website at

This message contains confidential information and is intended only
for the individual named. If you are not the named addressee you
should not disseminate, distribute or copy this e-mail. Please
notify the sender immediately by e-mail if you have received this
e-mail by mistake and delete this e-mail from your system.
E-mails are not encrypted and cannot be guaranteed to be secure or
error-free as information could be intercepted, corrupted, lost,
destroyed, arrive late or incomplete, or contain viruses. The sender
therefore does not accept liability for any errors or omissions in the
contents of this message which arise as a result of e-mail transmission.
If verification is required please request a hard-copy version. This
message is provided for informational purposes and should not be
construed as a solicitation or offer to buy or sell any securities
or related financial instruments.

Boost list run by bdawes at, gregod at, cpdaniel at, john at