C++中的类加多线程代码修炼

背景：现在在做一个目标跟踪的项目，需要实时的从工业相机中获取图像，然后再跟踪图像上的目标物，由于起初为了测试跟踪算法，就把“从相机获取图像”和“跟踪处理”都放在了主线程中，在实际测试时，直接从相机获取图像时，跟踪处理部分帧率出现周期性卡顿的问题，而直接读取本地的视频数据时跟踪部分帧率很稳。因为“获取图像”和“跟踪处理”在一个线程中，所以两者是一条线上的蚂蚱，要快都快，要慢都满，所以我没必要在帧率测试上花时间了，另外考虑到，相机应该单独出来，一个是将一些相机的操作封装到一个类里面，另外需要将他放在一个线程中去，这样这个线程只顾获取图像就可以不受其他操作的影响。又考虑到以后还会有数据处理这一块，所以把跟踪这块也封装到一个类中，也放在一个单独的线程中去。

说自己是C++程序猿真是惭愧，使用C++也快5年了，期间也专门拿两个月专门来学习C++语法，但是一直以来练习的太少，导致现在的水平依然很低，今天问我老同事相关问题，他直接给我发了一个“头上顶着菜叶子的狗”，名副其实呀，我感觉我就是个菜狗，哈哈，我要尽早摆脱这个称号。

虽然我的C++功底不深厚，但是还是有一些基础和经验的，我知道第一步需要做的就是把架子搭建起来，然后通过了，然后再往里面填东西。

获取图像的类 CaptureThread.h

#ifndef CAPTURETHREAD_H
#define CAPTURETHREAD_H
namespace FDSST {
class CaptureThread {
public:
	CaptureThread();
	~CaptureThread();
	void Run();
	void Stream();
	void Pause();
	void Stop();
	bool quit;
private:
	bool pause_status;
};
}
#endif // CAPTURETHREAD_H

获取图像类实现:CaptureThread.cpp

#include <iostream>
#include "../include/capturethread.h"
#include <windows.h>

namespace FDSST
{
CaptureThread::CaptureThread()
{

	pause_status = false;
	quit = false;
}
CaptureThread::~CaptureThread()
{
}
void CaptureThread::Run()
{
    std::cout << "capture_thread!!!" << std::endl;
	return;
}
void CaptureThread::Stream()
{
	pause_status = false;
}

void CaptureThread::Pause()
{
	pause_status = true;
}

void CaptureThread::Stop()
{
	pause_status = true;
	quit = true;
}
}

跟踪类:TrackingThread.h

#ifndef TRACKINGTHREAD_H
#define TRACKINGTHREAD_H

namespace FDSST
{
class Tracking {
public:
	Tracking();
	~Tracking();
	void Run();
};
}
#endif

跟踪类实现：TrackingThread.cpp

#include <iostream>
#include "../include/trackingthread.h"
#include <windows.h>
namespace FDSST
{
	Tracking::Tracking(){}
	Tracking::~Tracking(){}
	void Tracking::Run()
	{
		std::cout << "tracking_thread!!!" << std::endl;
        return;
	}
}

我学着orb-slam代码结构的样子，整出来一个System类:System.h

#ifndef SYSTEM_H
#define SYSTEM_H
#include <thread>
#include "../include/Trackingthread.h"
#include "../include/capturethread.h"
namespace FDSST
{
class Tracking;
class CaptureThread;

class System {
public:
	System();
	~System();
private:
	Tracking* mpTracker;
	CaptureThread* mpCapturer;

	std::thread* mptTracking;
	std::thread* mptCapturing;
};
}
#endif

Syetem.cpp

在System类的构造函数中，创建两个线程，将CaptureThread类和Tracking类中的成员函数Run作为线程的入口

#include "../include/System.h"
#include <thread>

namespace FDSST {
	System::System()
	{
		mpCapturer = new CaptureThread();
		mptCapturing = new std::thread(&FDSST::CaptureThread::Run, mpCapturer);
        std::cout << "Capture thread has been created" << std::endl;

		mpTracker = new Tracking();
		mptTracking = new std::thread(&FDSST::Tracking::Run, mpTracker);
        std::cout << "Tracking thread has been created" << std::endl;
	}
	System::~System()
	{
	
	}
}

我们想象的多线程的样子都是，代码执行起来之后，两个线程中代码段一直在执行，直到到达代码控制它结束的时候。看我在主函数中是怎么调用System的构造函数，从而创建两个线程的。

我最初的写法是这样的：

#include <iostream>
#include "../include/System.h"
#include <windows.h>

int main(int argc, char** argv)
{
	FDSST::System TRACK();
	return 0;
}

此时代码可以编译通过，但是我发现程序并没有进入到System类中的构造函数中去，所以线程被创建的打印未输出。我很纳闷，为啥那块代码没有被执行呢？

我就去请教我的老同事，一个很低调很牛的boy，我把主函数和System.cpp的内容截图发给他，他一看就知道了，他让我把FDSST::System TRACK();中的括号去掉，原因是，我在System.cpp中的默认构造函数中执行创建线程的操作，而如果我的TRACK后面带有括号，就不会调用默认构造函数，我这种写法在某些编译器上应该会出错的。

也就是说，
    如果我使用的是默认的构造函数那么就得这样定义 :FDSST::System TRACK;
    如果我定义了带参数的构造函数，那就可以定义为：FDSST::System TRACK(paras);

上面的问题解决之后，CaptureThread和TrackingThread类中Run函数中的打操作只被执行了一次，我就又纳闷了，咋跟我想象的不一样，应该一直执行下去，我继续问我那个老同事事，他说需要加上while(1),我知道了是在Run函数里面加while(1).上面的Run函数改成下面这种写法。

void CaptureThread::Run()
{
	while (1)
	{
		std::cout << "capture_thread!!!" << std::endl;
	}
	return;
}

void Tracking::Run()
{
	while (1)
	{
		std::cout << "tracking_thread!!!" << std::endl;
	}
    return;
}

然后我发现Run函数中的打印操作还是只执行了一次，我又纳闷了，又问我那老同事，他说，"你的主函数结束了吧”，让我在main函数中添加Sleep()函数。我把主函数改成下面这个样子

#include <iostream>
#include "../include/System.h"
#include <windows.h>

int main(int argc, char** argv)
{
	FDSST::System TRACK();
    Sleep(10000);
	return 0;
}

修改之后，代码可以一直执行了，但是我发现，两个线程的输出呈现交替执行的现象，一个线程执行很多次，然后另外一个线程再执行很多次，交替执行，像下面这样。

 我又问我老同事，他让我在每一个Run函数中也加上Sleep()，我就把Run函数中加上Sleep()

void CaptureThread::Run()
{
	while (1)
	{
		std::cout << "capture_thread!!!" << std::endl;
        Sleep(2);
	}
	return;
}

void Tracking::Run()
{
	while (1)
	{
		std::cout << "tracking_thread!!!" << std::endl;
        Sleep(2);
	}
    return;
}

这下再执行：就正常了，接下来就可以往里面实现功能了。虽然这个框架很简单，但是在搭建出来的过程中让我学到很多东西，所以将难得问题拆分成简单的问题，一步一步的来，就可以解决。