CODEWITHSUNDEEP
c++multithreadingstdthread
uliwitness
uliwitness

Reputation: 8843

Get std::thread's thread:id before it runs?

I'm trying to build a thread-safety layer on top of C++ 11's std::thread where each object is assigned to an owning thread, and certain calls can raise a hard error when they are used on the wrong thread. The owning thread is the only one that can transfer an object to another thread.

I have it all working, except that I can't find a way to get a thread's thread::id before it is actually running. And I need to attach the new thread's ID to the object before I hand it off.

If I use

std::thread newThread( [theObject]()
                       {
                           // use theObject here.
                       } );

The earliest point I can get the thread's ID is after the definition of the thread object, at which point the thread is already running.

I see there is a default constructor for std::thread, but I can't see a way to give it a function to run on the thread afterwards.

Is there a way to perform two-step construction on a thread, or control the thread's ID at time of creation?

Upvotes: 1

Views: 2235

Answers (4)

ObliteratedJillo
ObliteratedJillo

Reputation: 5166

Start each thread inactived by passing a unique std::promise parameter, get the thread id first ( thread id is used as a pass by reference parameter for the purpose) afterwards let it wait for the promise to be set by the thread manager. This will also remove the hassle of using a conditional variable.

Edited Snippet

class smart_thread {
public:
    smart_thread(std::function<void(void)> task)
    {
        thread_ = std::thread([=]() {
            id_ = std::this_thread::get_id();
            // wait here till activated
            future_.get();
            if(active_) task();
        });
    }

    void activate()  {
        promise_.set_value();
        active_ = true;
    }

    ~smart_thread() {
        if(!active_) promise_.set_value();
        thread_.join();
    }    
private:
    std::thread::id id_;
    std::atomic<bool> active_ = false;
    std::thread thread_;
    std::promise<void> promise_;
    std::future<void> future_ = promise_.get_future();
};

void main()
{
    auto task = []() { std::cout << "Hello World\n"; };
    smart_thread thread(task); // start thread inactive mode
    thread.activate(); // activate thread
}

Upvotes: 3

dgnuff
dgnuff

Reputation: 3557

Would it be possible to create a template class that accepts the thread routine in the form of a std::function<void(T *object)>. This can easily be done with an anonymous closure if additional parameters need to be passed in.

template <class T>
class ThreadWrapper
{
public:
    ThreadWrapper(std::function<void(T *object)> function, T *object) :
    {
        m_thread = std::thread(WrapFunction, function, object);
        //optionally
        m_thread.detach();
    }
    static void WrapFunction(ThreadWrapper *wrapper, std::function<void()> function, T *object)
    {
        // Get the thread id and save in the object
        object->SetThreadId(get_id());
        // Now actually invoke the thread routine, with the id already installed.
        function(object);
    }
}

// Cleanup is left as an exercise for the reader.

Beware of bugs in the above code - it's completely untested. :-) :-)

Upvotes: 0

templatetypedef
templatetypedef

Reputation: 373082

Rather than getting the ID of the thread before it starts running, you could consider having the function the thread executes do some initial setup before taking off. For example, you could do something like this:

bool isReady = false;
bool wasReceived = false;
std::mutex mutex;
std::condition_variable condition;

std::thread newThread([theObject, &isReady, &mutex, &condition] {
   /* Wait until we've been cleared to go. */
   std::unique_lock<std::mutex> lock(isReady);
   condition.wait(lock, [&isReady] { return isReady; });

   /* Signal that we're done. */
   wasReceived = true;
   lock.unlock();
   condition.notify_one();

   /* Put code here to do whatever it is that the thread should do. */
});

/* Read the thread's ID. It's currently waiting for us. */
auto id = newThread.get_id();

/* Tell the thread that we're ready for it. */
std::unique_lock<std::mutex> lock(mutex);
isReady = true;
condition.notify_one();

/* Wait until the thread has confirmed that it's ready. */
condition.wait(lock, [&] { return wasReceived; });

This creates the thread and has it sit and wait until the creator has a chance to read its ID. Once that's happened, the creator then waits until the thread confirms that it's ready to go, and from there you can work with the thread ID however you'd like.

Beware of bugs in the above code - it's completely untested. :-)

Upvotes: 6

Jerry Coffin
Jerry Coffin

Reputation: 490573

No--as soon as you create a thread, it starts to run. If you want to get its ID before it does (much of) anything, you probably want to create a little wrapper, where you pass the thread (for example) a CV and a queue where it deposits its output.

Then when the thread starts up, it retrieves its own ID, deposits it in the output queue, and then waits on the CV. When the parent has retrieved the ID, and is ready for the child to start doing something, it signals the CV, and off it goes.

Upvotes: 5

Related Questions