title: std::async not executing when specifying launch::async
body: <p>Maybe I'm missing the correct usage of the new <code>std::async</code> in C++11, however this statement (over at <a href="http://en.cppreference.com/w/cpp/thread/async" rel="nofollow">cppreference.com</a>): </p>
  
  <blockquote>
    <p>If the async flag is set (i.e. policy &amp; std::launch::async != 0), then async executes the function f on a separate thread of execution as if spawned by std::thread(f, args...), except that if the function f returns a value or throws an exception, it is stored in the shared state accessible through the std::future that async returns to the caller.</p>
  </blockquote>
  
  <p>Makes me think that my thread should start immediately with this statement:</p>
  
  <pre><code>std::async(std::launch::async, MyFunctionObject());
  </code></pre>
  
  <p>Without having to wait for calling the <code>std::future::get()</code>. This seems to not be the case (compiling with MSVC 13). If this is not triggered by this statement itself, how should this get triggered if I don't care about the return value of the <code>std::future</code> object?</p>
  
  <p>Example: </p>
  
  <pre><code>#include &lt;thread&gt;
  #include &lt;iostream&gt;
  #include &lt;array&gt;
  #include &lt;future&gt;
  
  static std::mutex write_mutex;
  
  class Cpp11Threads {
  public:
      // Function operator for Function-Object
      void operator()() {
          const int num_threads = 50;
  
          // Static std array
          std::array&lt;std::thread*, num_threads&gt; worker_threads;
  
          // Range based
          for (std::thread*&amp; thread : worker_threads) {
  
              // Lambda expression
              thread = new std::thread(
                  [] {
                      static int i = 0;
                      write_mutex.lock();
                      std::cout &lt;&lt; "Hello, I am happy Std thread #" &lt;&lt; i++ &lt;&lt; std::endl;
                      write_mutex.unlock();
                  });
          }
  
          for (std::thread*&amp; thread : worker_threads) {
              thread-&gt;join();
              delete thread;
  
              // nullptr instead of NULL
              thread = nullptr;
          }
      }
  };
  
  int main() {
      std::async(std::launch::async, Cpp11Threads());
      return 0;
  }
  </code></pre>