关于std::thread的封装引发的一系列问题及其解答

某日突发奇想，想封装自己的thread，想要实现的效果类似java的thread

#include 
#include 

using namespace std;

class mThread :public std::thread {
public:
	mThread() : thread(mThread::run){ this->detach();}

	virtual ~mThread() { is_live = false; }
private:
	void thread_callback();

	void run();

private:
	bool is_live;
};

void mThread::thread_callback() {
	cout << "mThread run" << endl;
}

void mThread::run() {
	is_live = true;
	while (is_live) {
		std::this_thread::sleep_for(std::chrono::milliseconds(1000));
		thread_callback();
	}
}

int main() {
	mThread demo;

	int n;
	cin >> n;
	return 0;
}

（声明一下这里为什么不用仿函数，因为thread构造函数接受的是一个仿函数的对象而不是指针，仿函数作为参数传进去的是一个this解引用对象的一个拷贝，而不是本来的this）

这是我以为的代码写法
结果编译报错，原来类的成员函数的地址要用取地址符号，然后修改构造函数

mThread() : thread(&mThread::run){ this->detach();}

然后又报错了，原来他无法调用函数run，因为run函数不是void run(),而是void mThread::run(),再说详细一点就是

class mThread{
public:
	void run(){
		cout<<"run"<<endl;
	}
}
int main(){
	void (mThread::*demo1)() = &mThread::run;//这行能编译通过，
	void (*demo2)() = &mThread::run;//这行报错
}

然后我们如何以函数指针的方式调用这个run函数呢？
要这样

int main() {
	void (mThread::*demo1)() = &mThread::run;
	mThread a;
	(a.*demo1)();//间接调用编译通过

	demo1();//直接调用编译报错
}

看到了吧，我们只能通过一个a对象，来间接调用这个函数，而std::thread哪儿去给你找一个临时对象来调用这个函数呢，所以编译通不过。

那我们要怎么样才能让std::thread能正常的使用我们传进去的run函数呢？
这里普及一个小知识

class mThread {
public:
	void run() {
		cout << "run" << endl;
	}
};
int main(){
	void (mThread::*demo1)()  = null;//声明一个函数指针	demo1
	void (*demo2)(mThread *This) = null;//声明一个函数指针demo2
	demo2 = ((void (*)(mThread *))  (*(int*)&demo1));

	demo2(new mThread());
}

这时候能成功的输出run。

在这里虽然不能直接将demo1和demo2相互赋值，但是你应该明白的是，demo1和demo2实际上是同一个类型，只要你明白c++是怎么实现面向对象的，那么你就明白为什么我说他们俩是同一个类型。推荐一本书<深入探索c++模型>，懒得看书就看我下面写的

你看类的成员函数，能够调用类的对象的一些属性，同时能够修改对象的一些属性，拿他怎么知道修改的是那个对象的属性呢，当然是函数传了一个this指针进去啦

就比如这个run函数，你以为他是void run();其实他是 void run(mThread *this)，最后一个参数是编译器帮你加上去的，所以说demo1和demo2实际上是同一个类型，只是在编译器哪里不是同一个类型而已。

所以现在可以将之前的构造函数改成这样

mThread() : thread(&mThread::run,this){ this->detach();}

然后就可以编译成功了，附加完整代码

#include 
#include 

using namespace std;

class mThread :public std::thread {
public:
	mThread() : thread(&mThread::run,this,5){ this->detach();}

	virtual ~mThread() { is_live = false; }
public:
	void thread_callback() {
		cout << "mThread run" << endl;
	}

	void run(int a);

private:
	bool is_live;
};

void mThread::run(int a) {
	is_live = true;
	cout << a << endl;
	while (is_live) {
		std::this_thread::sleep_for(std::chrono::milliseconds(1000));
		thread_callback();
	}
}

int main(){
	mThread demo;

	int n;
	cin >> n;
	return 0;
}

后记
在这个例子里面有个关键的问题，就是我们默认了

void mThread::run(int a) = void run(mThread *this,int a)

然后结果也在我们的意料之中，但是这样写不总是对的，因为有的编译器会将this指针放在参数列表的最后，而不是向我们一样放在最前面，也就是这样

void mThread::run(int a) = void run(int a,mThread *this)

这一点在amd和Intel之间表现得尤其明显，早期的amd处理器就是this放在最后，而intel一直都是this放在最前面。所以这样写其实在有的编译器上会通不过。
下面是另一种写法

#include 
#include 

using namespace std;

class mThread;
void run(mThread* This,int a);
class mThread : public std::thread {
	friend void run(mThread* This, int a);
public:
	mThread() :std::thread(run,this,5) {
		this->detach();
	}
	virtual ~mThread() { is_live = false; }

	void thread_callback() {
		cout << "mThread run" << endl;
	}
private:
	bool is_live;
};

void run(mThread* This, int a) {
	cout << a << endl;
	This->is_live = true;
	while (This->is_live) {
		std::this_thread::sleep_for(std::chrono::milliseconds(1000));
		This->thread_callback();
	}
}

int main(){
	mThread demo;

	int n;
	cin >> n;
	return 0;
}

这样手动This就可以避免上述问题。