定义线程函数时的std :: thread表示法

Question

I understand the std::thread notation presented here and reproduced as follows

#include <iostream>
#include <utility>
#include <thread>
#include <chrono>
#include <functional>
#include <atomic>

void f1(int n)
{
    for (int i = 0; i < 5; ++i) {
    std::cout << "Thread " << n << " executing\n";
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
}

void f2(int& n)
{
    for (int i = 0; i < 5; ++i) {
        std::cout << "Thread 2 executing\n";
        ++n;
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
}

int main()
{
    int n = 0;
    std::thread t1; // t1 is not a thread
    std::thread t2(f1, n + 1); // pass by value
    std::thread t3(f2, std::ref(n)); // pass by reference
    std::thread t4(std::move(t3)); // t4 is now running f2(). t3 is no longer a thread
    t2.join();
    t4.join();
    std::cout << "Final value of n is " << n << '\n';
}

because the definition of f1 and f2 is within main but fail to understand

#ifndef THREADED_H_
#define THREADED_H_

class Threadme
{
    long count;

public:

    Threadme();

    void run(void);

    void delay(long);
};

#endif

#include "threaded.h"
#include <iostream>
#include <chrono>

Threadme::Threadme() : count(0) {}

void Threadme::delay(long seconds)
{
    std::chrono::steady_clock::time_point end_t = std::chrono::system_clock::now() + std::chrono::seconds(seconds);

    while(std::chrono::system_clock::now() < end_t)
       ;
}

void Threadme::run(void)
{
    while(count < 10)
    {
        ++count;

        std::cout << count << std::endl;

        delay(1);
    }

}

#include <cstdlib>
#include <thread>

#include "threaded.h"

int main(int argc, char *argv[]){

    std::thread t1(&Threadme::run, Threadme());

    t1.join();

    return EXIT_SUCCESS;
}

specifically the expression std::thread t1(&Threadme::run, Threadme()); as it relates to defining the threaded function run outside of main . Why the reference & and why the thread parameters is a constructor invocation?

Answer 1

&Foo::mem where Foo is a class type and mem a member (function or value) of Foo , is C++ notation for obtaining a pointer to a member (function or value). There exist a special syntax for invoking a member function pointer on an object, but this is usually sugared away by using std::mem_fun , which will turn a member function pointer into an ordinary function where the first argument has to be an object of the type the member function was taken from.

std::thread understands what is happening here and does exactly that: invoke Foo::mem on the object passed as the second argument.

A small example to reproduce this locally without actually involving std::thread :

#include <functional>

class Foo { void mem() {} };

int main() {
  Foo f;
  f.mem(); // normal invoke
  auto func = std::mem_fun(&Foo::mem);

  func(std::ref(f)); // invoke mem on f
  func(f); // invoke mem on a copy of f
  func(&f); // invoke mem on f through a pointer
}

Why don't we need the mem_fun when constructing std::thread ? It automatically detects those situations through an overload and does the right thing all by itself.

Answer 2

You can see a member function of ThreadMe as a function that accepts an implicit first parameter of type ThreadMe* - also known as this . This analogy is not 100% correct and might be shred to pieces by some language lawyer, but it serves for understanding the call you have there.

std::thread and many other classes/functions that accept functions and parameters for them, like eg std::bind and std::function accept pointers to member functions, followed by an object on which the function has to be called, or put otherwise, followed by that implicit first parameter.

So void ThreadMe::run() can be seen as void run(ThreadMe&); Then the call that bothers you is easy to understand. Consider your second example:

void f1(int n);
int n;
std::thread t2(f, n); //calls f in a new thread, passing n

now create the int just when it's needed:

std::thread t2(f, int()); //calls f, passing a copy of the int that has been created here...

with ints that might not make so much sense, but with an object it does:

void run(ThreadMe&);
std::thread t1(run, ThreadMe()); //conceptually the same as above

and since we know thet member functions are just a bit more than syntactic sugar for that implicit first argument, the call you have is still nothing else but the above:

void ThreadMe::run(); //implicit first argument is a ThreadMe&
std::thread t1(ThreadMe::run, ThreadMe()); //pass a copy of that newly created ThreadMe as the implicit first argument of the run method.

If you know lambdas, this is very similar, ie it passes a copy of a fresh ThreadMe to the thread that calls run on that copy::

ThreadMe threadMe;
std::thread t1([=](){ threadMe.run(); });

In fact, since the binding of parameters to functions that happens under the hood of std::thread 's constructor is somewhat unusual, I prefer using lambdas, since they explain explicitly anything the thread has to do. In this case I would not create that temporary ThreadMe to call the thread, I would create a nontemporary inside the thread itself:

std::thread t1([](){ 
  ThreadMe threadMe;
  threadMe.run(); 
});