基于Boost的数据处理器及线程安全队列、跨平台的信号量和互斥锁

最新推荐文章于 2023-12-02 12:04:42 发布

会飞行的小蜗牛

最新推荐文章于 2023-12-02 12:04:42 发布

阅读量753

点赞数

分类专栏：算法 C++

C++ 同时被 2 个专栏收录

146 篇文章 3 订阅

订阅专栏

算法

11 篇文章 0 订阅

订阅专栏

近半年主要是开发公司行情系统Feedhandler（一共十几个Feedhandler，包括沪深L1、L2，港股，国内期货，国际股票，国际期货等。）。此系统要求跨平台、大吞吐量，超低延迟，属于CPU密集型系统。在项目过程中，有几个比较好的封装类，跟大家一起分享一下。以下所有源代码可至 http://download.csdn.net/detail/great3779/3998262 下载

一。基于Boost的跨平台锁。封装了Boost的mutex，提供了lock和unlock方法。代码示例如下：

[cpp]view plaincopy 
   
 #pragma once  
   
 // Author: Huangzhidan | great3779@sina.com   
 // copyright: @Wind Information Co., Ltd (Wind Info) ShangHai  
 // Create time: 2011-09-10  
 // 封装了boost的mutex，能跨平台使用。  
   
 #include <boost/thread.hpp>  
   
 class CWnLock  
 {  
 public:  
     CWnLock(void) {}  
     ~CWnLock(void) {}  
 public:  
     virtual void lock() {m_lock.lock();}  
     virtual void unlock() {m_lock.unlock();}  
 protected:  
   boost::mutex m_lock;  
 };  

二。基于Boost的自动锁。相对之前的互斥锁，自动锁在发生异常时，能自动解锁，避免发生异常后，程序死锁。代码示例如下：

[cpp]view plaincopy 
   
 // WnScopedLock.h  
 #pragma once  
   
 // Author: Huangzhidan | great3779@sina.com   
 // copyright: @Wind Information Co., Ltd (Wind Info) ShangHai  
 // Create time: 2011-09-10  
 // 封装了boost的mutex的scoped_lock，能跨平台使用。相对于CWnLock，其优势在于发生异常时能自动解锁，避免线程死锁。  
   
 #include "WnLock.h"  
   
 class CWnScopedLock : public CWnLock  
 {  
 public:  
   CWnScopedLock(CWnLock& mutex);  
   virtual ~CWnScopedLock(void);  
 public:  
   virtual void lock() {return m_pMutex->lock();}  
   virtual void unlock() {return m_pMutex->unlock();}  
 private:  
   CWnLock* m_pMutex;  
 };  
   
 // WnScopedLock.cpp  
 #include "WnScopedLock.h"  
   
 CWnScopedLock::CWnScopedLock(CWnLock& mutex)  
 {  
   m_pMutex = &mutex;  
   m_pMutex->lock();  
 }  
   
 CWnScopedLock::~CWnScopedLock(void)  
 {  
   m_pMutex->unlock();  
 }  

三。基于Boost的事件信号通知。由于Boost原本的事件通知在使用时还需要带一把锁，使用过程也比较麻烦，不好理解。因此对其进行封装，封装后的CWnEvent类使用时类似Windows下的CEvent类，且能跨平台使用，效率也比较高（使用了之前的互斥锁和自动锁）。代码示例如下：

[cpp]view plaincopy 
   
 #pragma once  
   
 // Author: Huangzhidan | great3779@sina.com   
 // copyright: @Wind Information Co., Ltd (Wind Info) ShangHai  
 // Create time: 2011-09-10  
 // 封装了boost的condition_variable，使其使用方法很接近Windows的Event。其优势在于能跨平台使用。  
   
 #include "WnLock.h"  
 #include "WnScopedLock.h"  
 #include <boost/thread.hpp>  
 #include <boost/date_time/posix_time/posix_time.hpp>  
   
 class CWnEvent  
 {  
 public:  
     CWnEvent(void){}  
   virtual ~CWnEvent(void){}  
   
 public:  
   void wait()  
     {  
         CWnScopedLock scoped_lock(m_lock);  
         m_condition.wait(scoped_lock);    
     }  
   
     bool timed_wait(int nMillSec)  
     {  
         CWnScopedLock scoped_lock(m_lock);  
         return m_condition.timed_wait(scoped_lock, boost::posix_time::millisec(nMillSec));  
     }  
   
     void notify_one() { m_condition.notify_one(); }  
   
     void notify_all() { m_condition.notify_all(); }  
   
 private:  
   CWnLock m_lock;  
   boost::condition_variable_any m_condition;  
 };  

四。一个非常高效、使用简单、扩展性强的数据处理器。此数据处理器主要优点如下：
1. 跨平台
2. 将线程通信间比较难的线程安全、信号通知等机制均封装在对象中
3. 由于数据的传递完全依靠事件通知，因此数据的流转效率以及吞吐量均非常高（已经使用在公司海外股票FeedHandler上，吞吐量轻松突破每秒500,000个包）
4. 接口简单，使用非常方便（可参考BoostDemo程序）
5. 由于采用了模板技术以及运行时绑定技术，因此可扩展性非常强。（公司FeedHandler项目，已经在CDataHandler类上派生了数十个类，扩展性非常好）

以下是示例代码：

[cpp]view plaincopy 
   
 #pragma once  
   
 // Author: Huangzhidan | great3779@sina.com   
 // copyright: @Wind Information Co., Ltd (Wind Info) ShangHai  
 // Create time: 2011-09-10  
   
 // 一个可用于线程间传递数据的类。此类的优势在于：  
 // 1. 跨平台  
 // 2. 将线程通信间比较难的线程安全、信号通知等机制均封装在对象中  
 // 3. 由于数据的传递完全依靠事件通知，因此数据的流转效率以及吞吐量均非常高（已经使用在公司海外股票FeedHandler上，吞吐量轻松突破每秒500,000个包）  
 // 4. 接口简单，使用非常方便（可参考BoostDemo程序）  
   
 // 使用方法  
 // CDataHandler是一个基类，使用时定义子类对其进行继承。  
 // 继承类重写DataThread和DataFunc方法（一般情况下仅需重写DataFunc方法即可）  
   
 #include "AtomQueue/WnQueue.h"  
 #include "Synchronous/WnEvent.h"  
 #include <boost/thread.hpp>  
   
 // a pure virtual function  
 template <class T> class CDataHandler  
 {  
 public:  
     CDataHandler(void) {Start();}  
     virtual ~CDataHandler() {}  
   
 public:  
     // 单个通知接口（一般不需调用）  
     void NotifyOne() {m_event.notify_one();}  
   
     // 全部通知接口（一般不需调用）  
     void NotifyAll() {m_event.notify_all();}  
   
     // 推入流数据  
     void Put(T& t)  
     {  
         m_record_set.push(t);  
   
         // 发送通知信号  
         m_event.notify_one();  
     }  
   
     // 获取缓冲区buffer size的接口  
     int BufferSize() { return m_record_set.size(); }  
   
 protected:  
     // 处理数据的线程，可在运行时绑定  
     virtual void DataThread()  
     {  
         while(true)  
         {  
             m_event.wait();  
             while(!m_record_set.empty())  
             {  
                 T t;  
                 if(m_record_set.get(t))  
                 {  
                     DataFunc(t);  
                 }  
             }  
         }  
     }  
   
     // 处理数据的函数，可在运行时绑定  
     virtual void DataFunc(T& t) {}  
   
 // 以下为内部函数  
 protected:  
     // 开始运行  
     void Start()  
     {  
         boost::thread t(&CDataHandler::DataThread, this);  
     }  
   
 protected:  
     // 流数据集  
     CWnQueue<T> m_record_set;  
   
     // 信号  
     CWnEvent m_event;     
 };  

基于此类的派生类使用，可以参考源代码：
http://download.csdn.net/detail/great3779/3998262

更新于20130701，在构造函数中，增加了可以设置消费线程数量以及缓冲区大小。

[cpp]view plaincopy 
   
 #pragma once  
   
 // Author: Huangzhidan | great3779@sina.com   
 // copyright: @Wind Information Co., Ltd (Wind Info) ShangHai  
 // Create time: 2011-09-10  
   
 // 一个可用于线程间传递数据的类。此类的优势在于：  
 // 1. 跨平台  
 // 2. 将线程通信间比较难的线程安全、信号通知等机制均封装在对象中  
 // 3. 由于数据的传递完全依靠事件通知，因此数据的流转效率以及吞吐量均非常高（已经使用在公司海外股票FeedHandler上，吞吐量轻松突破每秒500,000个包）  
 // 4. 接口简单，使用非常方便（可参考BoostDemo程序）  
   
 // 使用方法  
 // CDataHandler是一个基类，使用时定义子类对其进行继承。  
 // 一般情况下仅需重写DataFunc方法即可（可满足99%需求）。如果对发包逻辑有特殊需求，则重写DataThread线程方法。  
   
 // Revise: 2012-12-18  
 // 1. 与CWnQueue及CWnEvent的关系从依赖更新为继承，接口暴露更丰富且清晰.  
 // 2. 开放了缓冲区阈值设置，避免了系统缓冲区的溢出.  
   
 // Revise: 20130731  
 // 1. 构造函数中能指定消费线程数据，做为一个多消费者数据处理机。  
 // 2. 增加了手动启动的接口  
   
 #include "WnQueue.h"  
 #include "WnEvent.h"  
 #include <boost/thread.hpp>  
   
 // a data processor handler.  
 template <class T> class CDataHandler : public CWnQueue<T>, public CWnEvent  
 {  
 public:  
   ///< threadNum: 消费线程数目，默认为1  
   ///< threshold: 内部缓冲区阈值，默认为无限  
     CDataHandler(int threadNum = 1, bool autoStart = true, int threshold = 0) : m_thread_num(threadNum), m_threshold_size(threshold), m_bStart(false)  
   {  
     if(autoStart)  
     {  
       Start();  
       m_bStart = true;  
     }  
   }  
     virtual ~CDataHandler() {}  
   
 public:  
     // 推入元数据  
     void Put(T& t)  
     {  
         push(t);  
   
     if(m_threshold_size > 0 && size() > m_threshold_size)  
       clear();  
     else  
       notify_one(); // send semaphore  
     }  
   
 public:  
   // start a run thread.  
   void Start()  
   {  
     if(!m_bStart)  
     {  
       for(int i = 0; i < m_thread_num; ++i)  
       {  
         boost::thread t(&CDataHandler::DataThread, this);  
       }  
     }  
   }  
   
 public:  
   ///< 设置消费线程数  
   void SetThreadNum(int threadNum) {m_thread_num = threadNum;}  
   
   ///< 设置队列缓冲区阈值  
   void SetBufferThreshold(int threshold) {m_threshold_size = threshold;}  
   
 protected:  
     // 数据处理线程. 如有特殊需要，请在子类中重写.   
     virtual void DataThread()  
     {  
         while(true)  
         {  
             wait(); // wait semaphore  
             while(!empty())  
             {  
                 T t;  
                 if( get(t) )  
                 {  
                     DataFunc(t);  
                 }  
             }  
         }  
     }  
   
     // 数据处理核心函数，请在子类中重写!  
     virtual void DataFunc(T& t) = 0;  
   
 private:  
   // 缓冲区阈值。一旦缓冲区达到此阈值，则清空所有缓冲区内容  
   int m_threshold_size;  
   
   ///< 内部消费线程数目  
   int m_thread_num;  
   
   ///< 处理机是否已启动的标识  
   bool m_bStart;  
 };  
 
   
 
 
  
  
 