How to test a singleton generic template to be thread safe?

Question

How do I make Singleton generic template, and how can I test it?

Right now I am interested in seeing with my own eyes that 2 threads that invoke get_instance() will get the same pointer to the same singleton.

// g++ singleton.cpp -std=c++2a -pthread -o singleton
#include <iostream>
#include <string>
#include <vector>
#include <memory>
#include <mutex>
#include <thread>
#include <chrono>
#include <pthread.h>
#include <future>
using namespace std;
template <class T>
struct Singleton
{
    Singleton(const Singleton &) = delete;
    Singleton &operator=(const Singleton &) = delete;

    static T &get_instance()
    {
        static T _{allow()};
        return _;
    }

private:
    struct allow
    {
    };

protected:
    Singleton(allow) {}
};

class A : public Singleton<A>
{
    using Singleton<A>::Singleton;
    // Rest of functionality for class A
};

int main()
{
    auto &x = Singleton<A>::get_instance();
    auto &y = A::get_instance();

    printf("%p\n", &x);
    printf("%p\n", &y);

    void *p1;
    void *p2;
    // thread worker1(Singleton<A>::get_instance);
    // thread worker2(Singleton<A>::get_instance);
    // worker1.join();
    // worker2.join();

    printf("%p\n", p1);
    printf("%p\n", p2);

    // compiler error
    // auto z = A();
}

Side note: [Inherently thread-safe singleton](https://stackoverflow.com/a/1008289/4581301) — user4581301, May 05 '22 at 19:55
FWIW, if you use a Meyers singleton, thread safety is guaranteed by the language itself. — NathanOliver, May 05 '22 at 19:56
what is Meyes singleton ? and i saw some of the implementations but it was really annoying trying to figure out how to make it also a generic template because i need a generic template,, if you know how to make the singlton with generic , the shorter way i will be so happy to see it ! — Dolev Dublon, May 05 '22 at 19:58
What you have is a singleton wrapper for `T`; it does not turn `T` into a singleton. I can still make infinite numbers of `T`s simply by ignoring `Singleton` and instantiating `T` by itself. — user4581301, May 05 '22 at 20:00
@MayaCohen `template T& get_instance(){static T instance; return instance};`, called like `get_instance()`. Basically what you did to the mutex in your code. — Quimby, May 05 '22 at 20:03
@user4581301 can you give me an example of how you would do it ? and how to fix it ? — Dolev Dublon, May 05 '22 at 20:04
I've never tried, but perhaps `Singleton` becomes a base class and you employ [CRTP](https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern)? — user4581301, May 05 '22 at 20:06
can you explain a bit more what do you mean when you say a base class and you employ ? — Dolev Dublon, May 05 '22 at 20:06
I would recommend `T` having private constructor and public static `get_instance` method I posted above. That way no one but the method can construct an instance of `T`. — Quimby, May 05 '22 at 20:07
Gimme a sec. Someone must have done this already. And here we go: [Implementing Singleton with CRTP](https://stackoverflow.com/questions/51974670/implementing-singleton-with-crtp) — user4581301, May 05 '22 at 20:07
@user4581301 that is not thread-safe, is it? (But can be fixed with the same approach) — Quimby, May 05 '22 at 20:08
That one isn't, but you can easily Meyer-ize it: `static T& get_instance() { static T instance; return instance; }` and lose the `instance` member variable. — user4581301, May 05 '22 at 20:09
The concept when you make a base class and inherit is CRTP? if so , do i have to use the Singleton this way. and only in this way ? if i will use the post you gave me — Dolev Dublon, May 05 '22 at 20:10
how would i test it for having the same instance with a lot of threads ? — Dolev Dublon, May 05 '22 at 20:11
[Second answer Is what the asker's looking for](https://stackoverflow.com/a/51976202/4581301) — user4581301, May 05 '22 at 20:11
[Scott Meyers](https://en.wikipedia.org/wiki/Scott_Meyers) was one of C++'s finest public minds before he retired. His books are getting a bit long in the tooth, but many are still valuable additions to a C++ programmer's library. — user4581301, May 05 '22 at 20:14
Let us [continue this discussion in chat](https://chat.stackoverflow.com/rooms/244520/discussion-between-maya-cohen-and-user4581301). — Dolev Dublon, May 05 '22 at 20:16
hey!l ```auto& x = Singleton::get_instance();``` ```auto& y = A::get_instance(); ``` i say this in the main function of the second answer you gave me what is the diffrance between them ? — Dolev Dublon, May 05 '22 at 20:18
In the first, you have `Singleton` specialized around `A`. In the second `A` is itself the singleton. Testing a multi-threaded application, which is what you are really after, is tricky. I'm not sure you can get a good answer here. Generally proving there are no unforeseen effects comes down to a formal proof demonstrating it can't fail or extensive testing of every possibility you can think of and hoping you thought of everything — user4581301, May 05 '22 at 20:22
i just want to see it in my eyes with a something like 50 threads but i cant make the code compile with threads i dont understand what is the problem — Dolev Dublon, May 05 '22 at 20:25
Yes, the second answer is guaranteed to be thread safe by the C++ Standard. This doesn't mean that the compiler implementor can't screw up, but it's exceedingly unlikely in a major compiler implementation used by millions of coders. — user4581301, May 05 '22 at 20:26
hey ! i edited my question , see the Edit 2 , i took the code from the second answer and tried to invoke ``` thread worker1(Singleton::get_instance()); // throw error``` but it throws an error , do you think that it is possible to make it work the way i expect it to be ? or it is not possible ? — Dolev Dublon, May 05 '22 at 20:30
`thread worker1(Singleton::get_instance());` calls the function and passes the result to the `thread` constructor rather than passing the function to the `thread` constructor for the thread to call. Lose the brackets: `thread worker1(Singleton ::get_instance);` — user4581301, May 05 '22 at 20:35
thanks a lot I really appreciate it! i have one last question , how do i make it so i get the return pointer to the singleton and print it ? — Dolev Dublon, May 05 '22 at 20:43
your question is now very long and hard to read and comprehend. I suggest to wrap it up into a single clear question. Note that you need not / should not add "Edit : ..." to the question, this makes it just harder to read and understand. If someone is interested in the edit history of the question they can see it here: https://stackoverflow.com/posts/72132929/revisions — 463035818_is_not_an_ai, May 05 '22 at 21:01
When you want a value back when the thread is done, consider using a [`std::future`](https://en.cppreference.com/w/cpp/thread/future) — user4581301, May 05 '22 at 21:02
i tried reading the example from the link but i dont understand what ``` // future from a packaged_task std::packaged_task task([]{ return 7; }); // wrap the function std::future f1 = task.get_future(); // get a future std::thread t(std::move(task)); // launch on a thread``` what is package task ? what is get future what is move()? — Dolev Dublon, May 05 '22 at 21:10

How to test a singleton generic template to be thread safe?

0 Answers0