CAFFE源码学习笔记之五-internal_thread

一、前言

该类实际是boost::thread的包裹器。boost十分强大，可以不用修改就在linux和windows使用，避免了使用内核函数的移植性问题。

二、源码分析

类的构造函数就默认初始化boost::thread，析构函数直接调用线程停止函数。

成员函数包括开始线程，结束线程，判断线程是否开始，要求线程结束

class InternalThread {
public:
InternalThread() : thread_() {}
virtual ~InternalThread();

void StartInternalThread();

void StopInternalThread();

bool is_started() const;

protected:
/* Implement this method in your subclass
with the code you want your thread to run. */
virtual void InternalThreadEntry() {}

/* Should be tested when running loops to exit when requested. */
bool must_stop();

private:
void entry(int device, Caffe::Brew mode, int rand_seed,
int solver_count, int solver_rank, bool multiprocess);

shared_ptr<boost::thread> thread_;
};

}  // namespace caffe

具体实现：

如何开始线程？

首先，要将全局的资源搬运过来;

然后，用搬运过来的原始的全局资源初始化本线程的全局资源？？？

最后，初始化boost::thread。

void InternalThread::StartInternalThread() {
CHECK(!is_started()) << "Threads should persist and not be restarted.";

int device = 0;
#ifndef CPU_ONLY
CUDA_CHECK(cudaGetDevice(&device));
#endif
Caffe::Brew mode = Caffe::mode();
int rand_seed = caffe_rng_rand();
int solver_count = Caffe::solver_count();
int solver_rank = Caffe::solver_rank();
bool multiprocess = Caffe::multiprocess();

try {
thread_.reset(new boost::thread(&InternalThread::entry, this, device, mode,
rand_seed, solver_count, solver_rank, multiprocess));//这里用函数指针加绑定参数的形式构造了thread
} catch (std::exception& e) {
LOG(FATAL) << "Thread exception: " << e.what();
}
}

其中entry函数就是用其他线程的全局资源初始化本线程的：

void InternalThread::entry(int device, Caffe::Brew mode, int rand_seed,
int solver_count, int solver_rank, bool multiprocess) {
#ifndef CPU_ONLY
CUDA_CHECK(cudaSetDevice(device));
#endif
Caffe::set_mode(mode);
Caffe::set_random_seed(rand_seed);
Caffe::set_solver_count(solver_count);
Caffe::set_solver_rank(solver_rank);
Caffe::set_multiprocess(multiprocess);

InternalThreadEntry();
}

如何判断线程开始了？

线程存在且是可以等待执行的：

bool InternalThread::is_started() const {
return thread_ && thread_->joinable();

如何结束线程？

要想主动终结一个线程是很费劲的，caffe也没有做这种费力不讨好的事情，而是被动的等待。

caffe采取是设置must_stop()函数自动检测终结条件的退出方式。

thread里的thread_->interruption_requested()提供中断检测。

bool InternalThread::must_stop() {
return thread_ && thread_->interruption_requested();
}

同时，caffe提供了从外部主动触发interrupt操作，然后为了使可能处于阻塞状态的线程苏醒，使用join()唤醒之。

void InternalThread::StopInternalThread() {
if (is_started()) {
thread_->interrupt();
try {
thread_->join();
} catch (boost::thread_interrupted&) {
} catch (std::exception& e) {
LOG(FATAL) << "Thread exception: " << e.what();
}
}
}

三、总结

该类掌控了线程的生命周期，是多线程系统的基石。