Mutexes are passé

And atomics. Of course. And other synchronization stuff that you know. In this art you'll read about a new, innovatory synchronization method in C++. We'll be using C++17 and clang ~8 (relying on Compiler Explorer).

Once, during regular beforesleep C++ standard reading, I've encountered such interesting paragraph in [stmt.dcl]:

Dynamic initialization of a block-scope variable with static storage duration or thread storage duration is performed the first time control passes through its declaration; such a variable is considered initialized upon the completion of its initialization. If the initialization exits by throwing an exception, the initialization is not complete, so it will be tried again the next time control enters the declaration. If control enters the declaration concurrently while the variable is being initialized, the concurrent execution shall wait for completion of the initialization.

>variable is considered initialized upon the completion of its initialization

>throwing an exception, the initialization is not complete

>concurrently while the variable is being initialized, the concurrent execution shall wait for completion

BENG! That's it! I've immediately forgot about mutexes, atomics etc.

MCVE

Let's start with something simple. A multithread accumulation.

int main()
{
    int sum{};

    auto concurrent_fun = [&sum]
    {
        sum += 3;
    };

    auto fun = [concurrent_fun]
    {
        for(auto i = 0u; i < 100000; ++i)
        {
            sync_call(concurrent_fun);
        }
    };

    auto t1 = std::thread{ fun };
    auto t2 = std::thread{ fun };

    t1.join();
    t2.join();

    std::cout << sum;
}

At the point of cout, sum should be 600000.

Now let's create a function called e.g. sync_call that will take any callable object and will take care of concurrent calls.

template <typename Callable>
void sync_call(Callable&& callable)

And now, The Magic. First, we need static variable.

template <typename Callable>
void sync_call(Callable&& callable)
{
    static auto _ 

calling our concurrent callable object should be executed during initialization of the variable => lambda for the rescue.

template <typename Callable>
void sync_call(Callable&& callable)
{
    static auto _ = [callable]
    {
        callable();
        return 0;
    }();
}

no we need to prevent from actual initialization. Of course by throwing.

template <typename Callable>
void sync_call(Callable&& callable)
{
    static auto _ = [callable]
    {
        callable();
        throw 0;
        return 0;
    }();
}

and of course, let's prevent from crashing by not caught exception

template <typename Callable>
void sync_call(Callable&& callable)
{
    try
    {
        static auto _ = [callable]
        {
            callable();
            throw 0;
            return 0;
        }();
    }
    catch (...)
    {}
}

At this point it looks really, really good. But I can imagine a situation, when someone would want to... I don't know, e.g. throw his own exception during our object call. Now we're catching anything. Not cool. Let's create our own exception.

namespace details
{
    class mutexes_are_passé : std::exception
    {
    public:
        const char* what() const noexcept override { return "Mutexes are passe"; }
    };
}

template <typename Callable>
void sync_call(Callable&& callable)
{
    try
    {
        static auto _ = [callable]
        {
            callable();
            throw details::mutexes_are_passé{};
            return 0;
        }();
    }
    catch (const details::mutexes_are_passé&)
    {}
}

Just right.

And the full code.

#include <iostream>
#include <thread>

namespace details
{
    class mutexes_are_passé : std::exception
    {
    public:
        const char* what() const noexcept override { return "Mutexes are passé"; }
    };
}

template <typename Callable>
void sync_call(Callable&& callable)
{
    try
    {
        static auto _ = [callable]
        {
            callable();
            throw details::mutexes_are_passé{};
            return 0;
        }();
    }
    catch (const details::mutexes_are_passé&)
    {}
}

int main()
{
    int sum{};

    auto concurrent_fun = [&sum]
    {
        sum += 3;
    };

    auto fun = [concurrent_fun]
    {
        for(auto i = 0u; i < 100000; ++i)
        {
            sync_call(concurrent_fun);
        }
    };

    auto t1 = std::thread{ fun };
    auto t2 = std::thread{ fun };

    t1.join();
    t2.join();

    std::cout << sum;
}

Final speech

If you read whole art, up to this point, I owe you one more thing.

This code won't compile under gcc by default.