struct atomic_ptr
{
  T* obj;
  unsigned cntr;
};

T* acquire(atomic_ptr* ptr)
{
  atomic_ptr tmp = ATOMIC_FETCH_ADD(ptr, 1 << 32);
  return tmp.obj;
}

void reset(atomic_ptr* ptr, T* n)
{
  atomic_ptr xchg = {n, 0};
  atomic_ptr tmp = ATOMIC_XCHG(ptr, xchg);
  // some manipulations with tmp to correctly handle
  // reference count for previous object
}

atomic_ptr<settings_t>         g_settings;
atomic_ptr<routing_table_t>    g_routing_table;
atomic_ptr<db_cache_t>         g_db_cache;

void worker_thread()
{
  while (request_t* req = get_next_request())
  {
    local_ptr<settings_t>      settings (g_settings);
    local_ptr<routing_table_t> routing_table (g_routing_table);
    local_ptr<db_cache_t>      db_cache (g_db_cache);
    // process req using settings, routing_table and db_cache
  }
}

R>atomic_ptr<settings_t>         g_settings;
R>atomic_ptr<routing_table_t>    g_routing_table;
R>atomic_ptr<db_cache_t>         g_db_cache;

R>void worker_thread()
R>{
R>  while (request_t* req = get_next_request())
R>  {
R>    local_ptr<settings_t>      settings (g_settings);
R>    local_ptr<routing_table_t> routing_table (g_routing_table);
R>    local_ptr<db_cache_t>      db_cache (g_db_cache);
R>    // process req using settings, routing_table and db_cache
R>  }
R>}
R>

atomic_ptr<settings_t>         g_settings;
void worker_thread()
{
  while(1)
  {
  settings.reset(new settings_t);
  }
}

atomic_ptr<settings_t>         g_settings;
void worker_thread()
{
  while(1)
  {
  settings.reset(new settings_t);
  atomic_ptr<settings_t> copy = settings;
  copy->foo();
  }
}

Параллельно и асинхронно с этим настройки, рутинговая таблица и кэш БД могут изменяться (точнее сказать подменяться на новые). Подмена может происходить с разной частотой, и по разным причиным. Но суть в том, что она нисколько не влияет (не тормозит) основную обработку, обработчики просто захватывают наиболее последнии версии необходимых объектов и производят обработку, используя их, потом отпускают. Когда последняя ссылка на старый объект уходит, то он удаляется.

O>atomic_ptr<settings_t>         g_settings;
O>void worker_thread()
O>{
O>  while(1)
O>  {
O>  settings.reset(new settings_t);
O>  }
O>}
O>

O>atomic_ptr<settings_t>         g_settings;
O>void worker_thread()
O>{
O>  while(1)
O>  {
O>  settings.reset(new settings_t);
O>  atomic_ptr<settings_t> copy = settings;
  copy->>foo();
O>  }
O>}
O>

O>но кроме академичности, он ничем не лучше варианта с boost::shared_ptr который написали вы, поставив почемуто там atomic_ptr

O>>atomic_ptr<settings_t>         g_settings;
O>>void worker_thread()
O>>{
O>>  while(1)
O>>  {
O>>  settings.reset(new settings_t);
O>>  }
O>>}
O>>

atomic_ptr<settings_t>         settings;
void worker_thread()
{
  while(1)
  {
  settings.reset(new settings_t);
  settings->foo();
  }
}

O>>но кроме академичности, он ничем не лучше варианта с boost::shared_ptr который написали вы, поставив почемуто там atomic_ptr

atomic_ptr<settings_t>         g_settings;
atomic_ptr<routing_table_t>    g_routing_table;
atomic_ptr<db_cache_t>         g_db_cache;

void worker_thread()
{
  while (request_t* req = get_next_request())
  {
    local_ptr<settings_t>      settings (g_settings);
    local_ptr<routing_table_t> routing_table (g_routing_table);
    local_ptr<db_cache_t>      db_cache (g_db_cache);
    // process req using settings, routing_table and db_cache
  }
}

void gui_thread::on_settings_changed_by_user(local_ptr<settings_t> s)
{
  g_settings = s;
}

void routing_table_update_thread()
{
  for (;;)
  {
    local_ptr<routing_table_t> table = recalculate_routing_table();
    g_routing_table = table;
    sleep(100);
  }
}

void db_cache_update_thread()
{
  for (;;)
  {
    local_ptr<db_cache_t> cache = local_from_db();
    g_db_cache = cache;
    sleep(10000);
  }
}

O>atomic_ptr<settings_t>         settings;
O>void worker_thread()
O>{
O>  while(1)
O>  {
O>  settings.reset(new settings_t);
O>  settings->foo();
O>  }
O>}
O>

O>>>но кроме академичности, он ничем не лучше варианта с boost::shared_ptr который написали вы, поставив почемуто там atomic_ptr

template <class T>
class local_ptr;

template <class T>
class atomic_ptr
{
public:
    explicit atomic_ptr(T *p) /* ... */ { /* ... */ }
    local_ptr<T> operator ->();
    // ...
};

template <class T>
class local_ptr
{
public:
    template <class Tx>
    local_ptr(atomic_ptr<Tx>) /* ... */ { /* ... */ }
    
    T *operator ->() { return m_p; }
    // ...
private:
    T *m_p;
    // ...
};

template <class T>
local_ptr<T> atomic_ptr<T>::operator ->()
    { return local_ptr<T>(*this); }
    
struct X
{
    void f() {}
};    
    
int main()
{
    atomic_ptr<X> p(new X);
    p->f();
}

QSharedPointer and QWeakPointer are thread-safe and operate atomically on the pointer value. Different threads can also access the same QSharedPointer or QWeakPointer object at the same time without need for locking mechanisms.

        inline void ref() const { d->weakref.ref(); d->strongref.ref(); }

        inline void internalSet(Data *o, T *actual)
        {
            if (d == o) return;
            if (o && !o->strongref)
                o = 0;
            if (o) {
                verifyReconstruction(actual);
                o->weakref.ref();
                o->strongref.ref();
            }
            if (d && !deref())
                delete d;
            d = o;
            this->value = d && d->strongref ? actual : 0;
        }