stdthread

I am trying to establish some heuristics to help me decide the appropriate std::thread class to use. As I understand it, from highest level (simplest to use, but least flexible) to lowest level, we have: std::async with/std::future (std::shared_future) (when you want to execute on a one-time throw-away producer-thread async) std::packaged_task (when you want to assign a producer, but defer the call to the thread) std::promise (???) I think I have a decent grasp of when to use the first two, but am still unclear about std::promise . std::future in conjunction with a std::async call, effectively

I am trying to learn std::threads from C++11 to make a threading system. I was wondering if there is a way to stop a thread from running (Not sleeping, but really destructing the thread or so to speak) without terminating the whole program. I know std::join exists, but that forces a thread to wait till all threads return. Is there another way to handle this? (For example for making a ThreadPool class without having to block a thread?) The C++ std::thread class is really just a minimal interface layered on top of some more complete implementation-defined threading package. As such, it only

#include<iostream> #include<thread> using namespace std; void f1(double& ret) { ret=5.; } int main() { double ret=0.; thread t1(f1, ret); t1.join(); cout << "ret=" << ret << endl; } The above code fails compilation with the following error message : g++ -std=c++14 -O2 -Wall -pedantic -pthread main.cpp && ./a.out In file included from /usr/local/include/c++/5.3.0/thread:39:0, from main.cpp:2: /usr/local/include/c++/5.3.0/functional: In instantiation of 'struct std::_Bind_simple<void (*(double))(double&)>': /usr/local/include/c++/5.3.0/thread:137:59: required from 'std::thread::thread(_Callable&

I am a little bit confused about the std::async function. The specification says: asynchronous operation being executed "as if in a new thread of execution" (C++11 §30.6.8/11). Now, what does that supposed to mean? In my understanding, the code std::future<double> fut = std::async(std::launch::async, pow2, num); should launch the function pow2 on a new thread and pass the variable num to the thread by value, then sometime in the future, when the function is done, place the result in fut (as long as the function pow2 has a signature like double pow2(double); ). But the specification states "as

So I've been trying to get the following code to compile and run on Windows by using a MinGW compiler. #include <iostream> #include <thread> void test() { std::cout << "test" << std::endl; } int main() { std::thread t(test); } I'm compiling with the following command: g++ -std=c++11 test.cpp -o test.exe Now the problem is the version of MinGW one should use and I've tried about all the versions I know of. MinGW-builds: thread-win32 MinGW-builds: thread-posix MinGW-w64: stdthread experimental rubenvb MinGW-w64: stdthread experimental rubenvb 4.7 Number 1 doesn't work, since GCC apparently only

In C++03 I used pthread with a self-built thread pool that always kept a couple of threads running (since pthread_create is slow), this way I was able to launch threads for small tasks without thinking about performance issues. Now, in C++11 we have std::thread . I guess the standard doesn't say anything about the specific implementation, so my question is about the standard library implementations. Are they generally opting for a pooled approach where constructing std::thread s is cheap (and e.g. doesn't call pthread_create on posix), or will std::thread just be a wrapper? In other words, is