Atomic Shared Pointer (std::atomic<std::shared_ptr<>)

Documentation

• https://en.cppreference.com/w/cpp/memory/shared_ptr/atomic2

Safe: Control Block Modification

See also

• std::shared_ptr

code/safe.cpp

#include <iostream>
#include <memory>
#include <thread>

int main()
{
    auto p = std::make_shared<int>(42);
    auto threadfunc = [p](){                           // <-- copy
        while (true)
            auto local_p = p;                          // <-- copy
    };
    std::thread t1(threadfunc);
    std::thread t2(threadfunc);
    t1.join();
    t2.join();
    return 0;
}

Sideways: Synchronizing With Thread Startup (1)

See also

• std::promise and std::future (And Some std::chrono) (Some Live Hacking)

• A note on use_count(): threads may not even running yet

• ⟶ use_count() is nothing to build upon

• Synchronization/communication needed

• ⟶ std::promise and std::future (And Some std::chrono) (Some Live Hacking)

code/safe-future-spoiler.cpp

#include <iostream>
#include <memory>
#include <thread>

int main()
{
    auto p = std::make_shared<int>(42);
    auto threadfunc = [p](){
        while (true)
            auto local_p = p;
    };
    std::thread t1(threadfunc);
    std::thread t2(threadfunc);

    std::cout << p.use_count() << std::endl;           // <-- moving target but safe

    t1.join();
    t2.join();
    return 0;
}

Sideways: Synchronizing With Thread Startup (2)

Trainer’s note

For simplicity, start only one thread

code/safe-future.cpp

#include <iostream>
#include <memory>
#include <thread>
#include <future>

int main()
{
    std::promise<void> started_promise;
    auto started_future = started_promise.get_future();

    auto p = std::make_shared<int>(42);
    auto threadfunc = [p, &started_promise](){
        started_promise.set_value();                   // <-- kick waiter loose
        while (true)
            auto local_p = p;
    };
    std::thread t(threadfunc);

    started_future.get();                              // <-- wait until kicked
    std::cout << p.use_count() << std::endl;

    t.join();
    return 0;
}

Unsafe: Assignment To Shared Pointer

code/problem.cpp

#include <memory>
#include <thread>

int main()
{
    auto p = std::make_shared<int>(42);
    auto threadfunc = [&p](){
        while (true)
            p = std::make_shared<int>(666);            // <-- **NOT** threadsafe!
    };
    std::thread t1(threadfunc);
    std::thread t2(threadfunc);
    t1.join();
    t2.join();
    return 0;
}

Solution: std::atomic_store<> Specialization

Documentation

• https://en.cppreference.com/w/cpp/memory/shared_ptr/atomic

• Deprecated in C++20

code/solution-atomic-function-specialization.cpp

#include <memory>
#include <thread>

int main()
{
    auto p = std::make_shared<int>(42);
    auto threadfunc = [&p](){
        while (true)
            std::atomic_store(&p, std::make_shared<int>(666));  // <-- ugly
    };
    std::thread t1(threadfunc);
    std::thread t2(threadfunc);
    t1.join();
    t2.join();
    return 0;
}

Solution: std::atomic<std::shared_ptr>

• Don’t want manually enable thread safety by using global function

• Better: want the object itself to be thread safe

• Drawback: no std::make_atomic_shared()

code/solution-atomic-specialization.cpp

#include <memory>
#include <thread>

int main()
{
    std::atomic<std::shared_ptr<int>> p = std::make_shared<int>(42);
    auto threadfunc = [&p](){
        while (true)
            p = std::make_shared<int>(666);
    };
    std::thread t1(threadfunc);
    std::thread t2(threadfunc);
    t1.join();
    t2.join();
    return 0;
}