Question

Each thread may insert an object to the container (at most once) using ‘insert’ function.
Hereafter, the thread may try to access this object using ‘get’ function.
Therefore, there is no race between ‘insert’ and ‘get’ when used by the same thread.
However, a different thread may try to insert its own object while another thread has called ‘get’

I need a container where this situation does not need any synchronization method.

The number of threads may vary dramatically between executions.

class Object;
class Container<Object>;

Container<Object> g_container;

void insert(int threadId)
{
    ScopedLock<Mutex> lock(insertMutex);
    Object obj;
    g_container[threadId] = obj;
}

Object get(int threadId)
{
    return g_container[threadId];
}

Answer 1

You can use a vector of container pointers. Each thread manages their own container instance, and registers it with the array of container pointers.

template <typename T>
struct Container {
    Mutex insertMutex;
    ContainerType<T> container;
    int index;
    void insert (T &obj) {
        ScopedLock<Mutex> lock(insertMutex);
        container.insert(obj);
    }
    T get () {
        return *container.begin();
    }
    void register_container () {
        if (index != 0) return;
        if (counter == MAX_THREADS) throw 0;
        index = ++counter;
        ScopedLock<Mutex> lock(registerMutex);
        containers.push_back(this);
    }
    static std::vector<Container *> containers;
    static Atomic<int> counter;
    static Mutex registerMutex;
};

template <typename T>
std::vector<Container<T> *> Container<T>::containers;

template <typename T>
Atomic<int> Container<T>::counter;

template <typename T>
Mutex Container<T>::registerMutex;

Now, you can iterate over the Container<T>::containers to access all containers.