我看的一下午才明白的，因为吧，我之前都是不知道与boost::thread相关的任何知识，然后开始看各种资料啊。。。
妈的，我就是一个小白，没一点基础的。。
总的来说：blocking_queue实现一个阻塞队列，它利用了生成者与消费者的设计模式，怎么说呢？、
首先吧，你要有一个queue（队列，c++里的一种容器），对它的操作有push与pop。 push即向队列里压入数据，相当于一个生产者，然后呢，pop把数据弹出队列，相当于一个消费者。。但是呢，生产者与消费者的速度可能不一样（即push与pop的速度）啊，那怎么办呢？？所以呢，要想办法让它们同步啊，方法即把这样queue变为一个阻塞队列啊。。。
下面看一下怎么实现的：
它的构造函数 ：
template<typename T>
BlockingQueue<T>::BlockingQueue()
: sync_(new sync()) {
}
在blockingqueue的头文件中包括：成员变量有：queue_(这是一个队列，类型为std::queue)
sync_(这是一个sync类，里面只有有两个成员变量：mutex_与condition_)
blockingqueue的成员函数：
void push(参数为一个要push进去的数据）
bool try_pop(参数为一个用于存放要pop出来的数据的指针），如果有数据可以pop出来，则返回true，否则为false
type pop（参数为一个用于存放要pop出来的数据的指针），它与上面的区别在于，如果queue为空时，它会等待。
bool try_peek(参数为一个用于存放队列最前端的数据的指针),它的作用就是试着返回一下queue最前端的数据；有数据写入，则true.
type peek(参数为一个用于存放队列最前端的数据的指针),与上面的区别在于没有数据，它会等待。
size_t size() ,它干的事情就是返回队列中数据的个数；
另外，对于blocking_queueg来说，它只会在pop与peek的时候进行相应的等待（如果队列为空就等啊），在push的时候不用等待的（应该队列不会满吧，它可以自动增加吧，应有可能取的速度较快吧，不会造成队列不断增加吧）；
补充一下sync的类：
// 这个类是在BlockingQueue类中定义的
template<typename T>
class BlockingQueue<T>::sync {
public:
mutable boost::mutex mutex_;
boost::condition_variable condition_;
};
还是在这里写一下实现代码吧：
#include <boost/thread.hpp>
#include <string>
#include "caffe/data_reader.hpp"
#include "caffe/layers/base_data_layer.hpp"
#include "caffe/parallel.hpp"
#include "caffe/util/blocking_queue.hpp"
namespace caffe {
template<typename T>
class BlockingQueue<T>::sync {
public:
mutable boost::mutex mutex_; //实现了一个mutex对象;
boost::condition_variable condition_; //也是实现了一个对象;
};
template<typename T>
BlockingQueue<T>::BlockingQueue()
: sync_(new sync()) {
}
template<typename T>
void BlockingQueue<T>::push(const T& t) {
// 在push操作过程中,创建一个scoped_lock的对象lock,利用它的构造函数来对
// mutex_进行加锁;
boost::mutex::scoped_lock lock(sync_->mutex_);
queue_.push(t);
lock.unlock(); //对互斥体解锁;
sync_->condition_.notify_one(); //给相应的wait中的线程发出通知;
}
template<typename T>
bool BlockingQueue<T>::try_pop(T* t) {
boost::mutex::scoped_lock lock(sync_->mutex_);
if (queue_.empty()) {
return false;
}
*t = queue_.front();
queue_.pop();
return true;
}
template<typename T>
T BlockingQueue<T>::pop(const string& log_on_wait) {
boost::mutex::scoped_lock lock(sync_->mutex_);
while (queue_.empty()) {
if (!log_on_wait.empty()) {
LOG_EVERY_N(INFO, 1000)<< log_on_wait; //当空的时候,输入相应的等待信息;
}
sync_->condition_.wait(lock); //线程进入wait的过程;等相应的通知;
}
T t = queue_.front();
queue_.pop();
return t;
}
template<typename T>
bool BlockingQueue<T>::try_peek(T* t) {
boost::mutex::scoped_lock lock(sync_->mutex_);
if (queue_.empty()) {
return false;
}
*t = queue_.front();
return true;
}
template<typename T>
T BlockingQueue<T>::peek() {
boost::mutex::scoped_lock lock(sync_->mutex_);
while (queue_.empty()) {
sync_->condition_.wait(lock);
}
return queue_.front();
}
template<typename T>
size_t BlockingQueue<T>::size() const {
boost::mutex::scoped_lock lock(sync_->mutex_);
return queue_.size();
}
template class BlockingQueue<Batch<float>*>;
template class BlockingQueue<Batch<double>*>;
template class BlockingQueue<Datum*>;
template class BlockingQueue<shared_ptr<DataReader::QueuePair> >;
template class BlockingQueue<P2PSync<float>*>;
template class BlockingQueue<P2PSync<double>*>;
} // namespace caffe