void lengthy_work(boost::shared_ptr<void> completion_flag) { ... }

void caller()
{
  boost::shared_ptr<void> completion_flag(new int);
  boost::weak_ptr<void> completion_check(completion_flag);
  boost::thread worker(lengthy_work, completion_flag);
  completion_flag.reset();

  ...
  case WM_TIMER:
    if (completion_check.expired()) 
    {
      OperationComplete();
    }
  ...
}

    long sp_counted_base::use_count() const // nothrow
    {
        return const_cast< int32_t const volatile & >( use_count_ );
    }

inline int32_t compare_and_swap( int32_t * dest_, int32_t compare_, int32_t swap_ )
{
    __asm__ __volatile__( "cas %0, %2, %1"
                        : "+m" (*dest_), "+r" (swap_)
                        : "r" (compare_)
                        : "memory" );

    return swap_;
}

  case WM_TIMER:
    if (worker.timed_join(0)) 
    {
      OperationComplete();
    }

boost::thread worker ([]()
{
  lengthy_work(...);
  PostMessage(current_thread_id, WM_WORK_ACCOMPLISHED, work_id, 0);
});

R>    long sp_counted_base::use_count() const // nothrow
R>    {
R>        return const_cast< int32_t const volatile & >( use_count_ );
R>    }

R>inline int32_t compare_and_swap( int32_t * dest_, int32_t compare_, int32_t swap_ )
R>{
R>    __asm__ __volatile__( "cas %0, %2, %1"
R>                        : "+m" (*dest_), "+r" (swap_)
R>                        : "r" (compare_)
R>                        : "memory" );

R>    return swap_;
R>}
R>

    // boost\smart_ptr\detail\sp_counted_base_solaris.hpp
    void release() // nothrow
    {
        if( atomic_dec_32_nv( &use_count_ ) == 0 )
        {
            dispose();
            weak_release();
        }
    }

Standard C Library Functions atomic_ops(3C)

NAME
atomic_ops — atomic operations

SYNOPSIS
#include <atomic.h>

DESCRIPTION
This collection of functions provides atomic memory opera-
tions. There are 8 different classes of atomic operations:

atomic_add(3C) These functions provide an atomic addition
of a signed value to a variable.

atomic_and(3C) These functions provide an atomic logical
'and' of a value to a variable.

atomic_bits(3C) These functions provide atomic bit setting
and clearing within a variable.

atomic_cas(3C) These functions provide an atomic comparison
of a value with a variable. If the com-
parison is equal, then swap in a new value
for the variable, returning the old value of
the variable in either case.

atomic_dec(3C) These functions provide an atomic decrement
on a variable.

atomic_inc(3C) These functions provide an atomic increment
on a variable.

atomic_or(3C) These functions provide an atomic logical
'or' of a value to a variable.

atomic_swap(3C) These functions provide an atomic swap of a
value with a variable, returning the old
value of the variable.

SunOS 5.10 Last change: 12 Aug 2004 1

Standard C Library Functions atomic_ops(3C)

ATTRIBUTES
See attributes(5) for descriptions of the following attri-
butes:

____________________________________________________________
| ATTRIBUTE TYPE | ATTRIBUTE VALUE |
|_____________________________|_____________________________|
| Interface Stability | Stable |
|_____________________________|_____________________________|
| MT-Level | MT-Safe |
|_____________________________|_____________________________|

SEE ALSO
atomic_add(3C), atomic_and(3C), atomic_bits(3C),
atomic_cas(3C), atomic_dec(3C), atomic_inc(3C),
atomic_or(3C), atomic_swap(3C), membar_ops(3C), attri-
butes(5)

NOTES
Atomic instructions ensure global visibility of atomically-
modified variables on completion. In a relaxed store order
system, this does not guarantee that the visibility of other
variables will be synchronized with the completion of the
atomic instruction. If such synchronization is required,
memory barrier instructions must be used. See
membar_ops(3C).

Atomic instructions can be expensive. since they require
synchronization to occur at a hardware level. This means
they should be used with care to ensure that forcing
hardware level synchronization occurs a minimum number of
times. For example, if you have several variables that need
to be incremented as a group, and each needs to be done
atomically, then do so with a mutex lock protecting all of
them being incremented rather than using the atomic_inc(3C)
operation on each of them.

SunOS 5.10 Last change: 12 Aug 2004 2

    // boost\smart_ptr\detail\sp_counted_base_solaris.hpp
    void release() // nothrow
    {
        membar_exit();
        if( atomic_dec_32_nv( &use_count_ ) == 0 )
        {
            membar_enter();
            dispose();
            weak_release();
        }
    }

std::atomic<bool> completion;

// on thread end, or manually by thread function:
completion.store(true, std:memory_order_release);

// completion polling
if (completion.load(std:memory_order_acquire) == true))
  ...

R>>boost::thread worker ([]()
R>>{
R>>  lengthy_work(...);
R>>  PostMessage(current_thread_id, WM_WORK_ACCOMPLISHED, work_id, 0);
R>>});
R>>

AG>