How can I declare an std::thread anonymously?

Question

Consider the following short program:

#include <thread>

int Foo() {
while (1);
}

int main(){
    std::thread t(Foo);
    std::thread s(Foo);

    // (std::thread(Foo));

    t.join();
}

This compiles and runs (forever), with

g++ -Wl,--no-as-needed DoubleBufferTest.cc -o DoubleBufferTest -std=c++0x -pthread

In the commented out line, I am trying to use the technique described here to declare a new thread anonymously. However, when that line is commented back in, I can compile but running gives the following error:

terminate called without an active exception            
Aborted (core dumped)

How can I correctly declare a thread anonymously?

Note, I am on g++ 4.4.7.

score 13 · Accepted Answer · answered Jan 17 '14 at 23:41

13

You can do it like this:

std::thread(Foo).detach();

answered Jan 17 '14 at 23:41

Howard Hinnant

206,506
52
449
577

@prajmus in what way? What about this, and how does it not work? – Yakk - Adam Nevraumont Jan 18 '14 at 00:44
I wrote a simple application with the code you presented and I does not create a thread – prajmus Jan 18 '14 at 00:54
@prajmus did you by any chance fall off the end of `main` right away? In short, how do you know no thread was created? I suspect it was created, it just never got around to running before your program finished. – Yakk - Adam Nevraumont Jan 18 '14 at 16:05
@Yakk you're right, it runs for a moment before the program finishes, sorry for not checking it fully earlier. – prajmus Jan 18 '14 at 16:16
One could also do `std::thread(Foo).join();`, but simply doing `Foo();` does the same thing and is far more efficient. – Howard Hinnant Jan 18 '14 at 16:36

zmb · Answer 2 · 2014-01-18T18:13:00.083

std::thread's destructor will call std::terminate if the thread has not been joined or detached.

So unfortunately you cannot create an anonymous thread object like this - you need a reference to the thread object in order to call either join() or detach().

Scott Meyers gave a talk at Going Native 2013 where he created an RAII class that wraps a thread and calls join in the destructor. You could do something similar:

class ThreadRAII {
public:
  ThreadRAII(std::thread&& thread): t(std::move(thread)) {}
  ~ThreadRAII() { if (t.joinable()) { t.join(); }

private:
  std::thread t;
};

See his blog post or talk for more info.

You could use it like this

(ThreadRAII(std::thread(Foo)));

However, the only reason you'd want to create a thread in this way is if you don't care when (or if) it ends, so in this case, join doesn't make much sense. You should modify the destructor to detach instead:

~ThreadRAII() { if (t.joinable()) { t.detach(); }

As suggested in the comments, you could make it even easier to use by perfect forwarding to an internal thread on construction:

class ThreadRAII2 {
public:    

    template <typename Func, typename ...Args>
    explicit ThreadRAII2(Func&& func, Args&&... args) :
        t(func, std::forward<Args>(args)...) {  }

    ~ThreadRAII2() { 
        if (t.joinable()) t.detach(); 
    }
private:
    std::thread t;
};

Then you can use it just like you originally wanted to, no detach necessary:

(ThreadRAII2(Foo));

Or, if Foo takes arguments (for example Foo(int)):

(ThreadRAII2(Foo, 42));

why not perfect forward on construct to an internal `std::thread`? — Yakk - Adam Nevraumont, Jan 18 '14 at 00:45
In this case `join()` does not make sense, since the last line in your code will wait until the thread has finished and then execution continues. You need `detach()`. — Ralph Tandetzky, Jan 18 '14 at 01:01

score 4 · Answer 3 · edited Jan 17 '14 at 23:39

I don't think this (the technique you are referring to) is possible with threads.

Take a look here;

30.3.1.3 thread destructor [thread.thread.destr]

~thread();

If joinable() then terminate(), otherwise no effects. [ Note: Either implicitly detaching or joining a joinable() thread in its destructor could result in difficult to debug correctness (for detach) or performance (for join) bugs encountered only when an exception is raised. Thus the programmer must ensure that the destructor is never executed while the thread is still joinable. — end note ]

Basically the temporary anonymous object (i.e. thread) you are creating is destructed right when execution continues to the next line which violates the above rule.

How can I declare an std::thread anonymously?

3 Answers3

Linked