stdthread

Why can't you pass an object by reference when creating a std::thread ? For example the following snippit gives a compile error: #include <iostream> #include <thread> using namespace std; static void SimpleThread(int& a) // compile error //static void SimpleThread(int a) // OK { cout << __PRETTY_FUNCTION__ << ":" << a << endl; } int main() { int a = 6; auto thread1 = std::thread(SimpleThread, a); thread1.join(); return 0; } Error: In file included from /usr/include/c++/4.8/thread:39:0, from ./std_thread_refs.cpp:5: /usr/include/c++/4.8/functional: In instantiation of ‘struct std::_Bind_simple

Well I have an issue with passing data into a thread using std::thread. I thought I understood the general semantics of copy constructors, etc. but it seems I don't quite grasp the problem. I have a simple class called Log that has hidden it's copy constructor thusly: class Log { public: Log(const char filename[], const bool outputToConsole = false); virtual ~Log(void); //modify behavior void appendStream(std::ostream *); //commit a new message void commitStatus(const std::string str); private: //members std::ofstream fileStream; std::list<std::ostream *> listOfStreams; //disable copy

Sometime I have to use std::thread to speed up my application. I also know join() waits until a thread completes. This is easy to understand, but what's the difference between calling detach() and not calling it? I thought that without detach() , the thread's method will work using a thread independently. Not detaching: void Someclass::Somefunction() { //... std::thread t([ ] { printf("thread called without detach"); }); //some code here } Calling with detaching: void Someclass::Somefunction() { //... std::thread t([ ] { printf("thread called with detach"); }); t.detach(); //some code here }

How can I check if a std::thread is still running (in a platform independent way)? It lacks a timed_join() method and joinable() is not meant for that. I thought of locking a mutex with a std::lock_guard in the thread and using the try_lock() method of the mutex to determine if it is still locked (the thread is running), but it seems unnecessarily complex to me. Do you know a more elegant method? Update: To be clear: I want to check if the thread cleanly exited or not. A 'hanging' thread is considered running for this purpose. Snps If you are willing to make use of C++11 std::async and std:

Relevant questions : About C++11: C++11: std::thread pooled? Will async(launch::async) in C++11 make thread pools obsolete for avoiding expensive thread creation? About Boost: C++ boost thread reusing threads boost::thread and creating a pool of them! How do I get a pool of threads to send tasks to , without creating and deleting them over and over again? This means persistent threads to resynchronize without joining. I have code that looks like this: namespace { std::vector<std::thread> workers; int total = 4; int arr[4] = {0}; void each_thread_does(int i) { arr[i] += 2; } } int main(int argc