Atualizar se não expirou no ponteiro fraco no contexto multithread

O cliente mantém um ponteiro compartilhado para um valor, digamos double, e um servidor atualiza esse valor em outro thread desanexado, mantendo um weak_pointer, o servidor verifica se weak_pointerexpirou e, se não estiver, é excluído de um vetor seguro. Suspeito que isso não funcionaria, pois poderia shared_ptrser destruído do lado do cliente entre minha leitura expired()(que considero thread-safe, pois imagino que se refere ao contador atômico de shared_ptr) e minha atualização do valor. Existe uma maneira de fazer com que a verificação expired()e uma lambdafunção atualizem o valor antes que ele seja destruído, por favor? Quero dizer:

struct server
{
public:
    static void subscribe(const std::shared_ptr<double>& d)
    {
        m_values.safe_push_back(d); //safely pushes back in the vector
    }

    void update()
    {
        auto updater = [](std::weak_ptr<double>& wd)
        {
            if(wd.expired()) wd = nullptr;
            else *wd += 2.0; //This is not thread safe I guess?
        };
        m_values.safe_remove_all(nullptr);
        m_values.safe_visit(updater);
    };

private:
    static safe_vector<std::weak_ptr<double>> m_values;
}

struct client
{
    void subcribe_sleep_print(const double random_seconds)
    {
        std::shared_ptr<double> d = std::make_shared<double>(0.0); //for the sake of the example assume we create subscribe before sleep
        server::subscribe(d);
        sleep_for_seconds(random_seconds); //sleeps for some random time in seconds.
        std::cout << *d << std::endl;
    }
}

Imagine server::updatee client::subcribe_sleep_printesteja rodando em threads diferentes. Isso não é seguro, pois shared_ptrpode ser destruído enquanto o servidor está gravando? Existe uma maneira de fazer isso sem atômicos ou mutexes definidos pelo usuário (eu)? Não me importo se for usado em segundo plano, desde que eu mesmo não os adicione (atômico/mutex), pois sei que o ponteiro compartilhado já usa um contador atômico.

EDIT : Não estou usando double no meu programa, estou usando um objeto thread-safe :) Portanto, a operação += pode ser assumida como thread-safe. Desculpe.