Question

A design problem which I’ve seen in several workplaces I’ve been to, yet without a satisfactory solution:

Suppose you have a system with dynamic number of threads.

Each thread must have an access to a set of “singletons”, the singletons have one and only one instance per thread (therefore they are not real singletons, but singletons per thread)

This set of singletons is known at compile time.

Each of the singletons has a default constructor (in order to simplify things, nevertheless, a solution that does not have this constrain would be great)

A satisfactory solution should have the followings:

1. Each thread can access any of its singletons in o(1) time

2. An access to a singleton is lock free

3. Adding a singleton to the ‘singleton set’ does not require new code written on the set side

4. The ‘singleton set’ is populated during compile time

I’m not sure if such a design is feasible. If it is, I assume that it requires a little bit of meta programming.

Thanks in advance for any of your insights.

Answer 1

Thread-local variables nicely solve the problem.

// in .h
class ThreadSingleton
{
private:
    static __thread ThreadSingleton* thread_specific_instance;

public:
    static ThreadSingleton* get() { return thread_specific_instance; }
    ThreadSingleton();
    ~ThreadSingleton();
};

// in .cc
__thread ThreadSingleton* ThreadSingleton::thread_specific_instance;

ThreadSingleton::ThreadSingleton() {
    if(thread_specific_instance)
        std::abort(); // one instance per thread please
    thread_specific_instance = this;
}

ThreadSingleton::~ThreadSingleton() {
    thread_specific_instance = 0;
}

// usage
int main() {
    // on thread entry
    ThreadSingleton x;

    // later anywhere in the thread
    ThreadSingleton* px = ThreadSingleton::get();
}

Each thread creates ThreadSingleton somewhere on the stack, normally in the thread function. Later on ThreadSingleton is accessible from anywhere in that thread via ThreadSingleton::get() which returns the singleton of the calling thread. (The above can be made a template to wrap any other class, I didn’t do it for simplicity of exposition).

Performance-wise accessing thread-local variables doesn’t require any calls (unlike using thread-specific storage created using pthread_key_create) See http://www.akkadia.org/drepper/tls.pdf for more details.