对象池的使用场景以及自动回收技术

[[420171]]

 对象池

在编程中，我们经常会涉及到对象的操作，而经常的操作模式如下图所示:创建对象->使用对象->销毁对象。

我们提供的服务有：成都网站建设、成都做网站、微信公众号开发、网站优化、网站认证、城步ssl等。为上1000家企事业单位解决了网站和推广的问题。提供周到的售前咨询和贴心的售后服务，是有科学管理、有技术的城步网站制作公司

而这个对象有可能创建的时候会需要构建很多资源，消耗比较大, 比如：在hiredis的SDK中每次都创建一个redisContext，如果需要查询，那就首先要进行网络连接。如果一直都是上图的工作方式，那将会频繁的创建连接，查询完毕后再释放连接。重新建立连接，让网络的查询效率降低。

这个时候就可以构建一个对象池来重复利用这个对象，并且一般要做到线程安全:

  1. 从对象池中获取对象，如果没有对象，则创建一个，并返回
  2. 使用对象
  3. 使用完成对象后，将对象还回对象池

那么符合如下条件的，应该适合使用对象池技术:

  • 有一些对象虽然创建开销比较大，但是不一定能够重复使用。要使用对象池一定要确保对象能够重复使用。
  • 这个对象构建的时候，有一些耗时的资源可以重复利用。比如redisContext的网络连接。又或者如果对象的频繁申请释放会带来一些其他的资源使用问题，比如内存碎片。重复利用能够提升程序的效率。
  • 对象池的数量应该控制在能够接受的范围内，并不会无限膨胀。

对象池的实现

首先介绍一下程序的样例对象Object, 其就接受一个初始化参数strInit。

 
 
 
 
    
  
  
  
  
  1. class Object 
    2. 
  
  
  
  
  2. { 
    3. 
  
  
  
  
  3. public: 
    4. 
  
  
  
  
  4.   Object(std::string strInit) : m_strInit(strInit)  
    5. 
  
  
  
  
  5.   {  
    6. 
  
  
  
  
  6.     std::cout << "Object()" << std::endl;  
    7. 
  
  
  
  
  7.   } 
    8. 
  
  
  
  
  8.   virtual ~Object()  
    9. 
  
  
  
  
  9.   {  
    10. 
  
  
  
  
  10.     std::cout << "~Object()" << std::endl; 
    11. 
  
  
  
  
  11.   } 
    12. 
  
  
  
  
  12. private: 
    13. 
  
  
  
  
  13.   std::string m_strInit; 
    14. 
  
  
  
  
  14. }; 
    15.

先来看看对象池的类图：

  • ObjectPool中采用std::list作为对象池的数据结构，存储的对象采用shared_ptr包裹。
  • GetObject获取一个对象，传入的参数为Object需要初始化的信息，如果池子里面没有，就创建一个返回，如果有就从池子中取出一个返回。
  • ReturnObject 当应用程序使用完毕后，调用这个方法还回对象到对象池

然后再来看看代码吧:

 
 
 
 
    
  
  
  
  
  1. class ObjectPool 
    2. 
  
  
  
  
  2. { 
    3. 
  
  
  
  
  3. public: 
    4. 
  
  
  
  
  4.   ObjectPool() { ; } 
    5. 
  
  
  
  
  5.   ~ObjectPool() { ; } 
    6. 
  
  
  
  
  6.   std::shared_ptr GetObject(std::string strInit) 
  
  
  
  
  7.   { 
    8. 
  
  
  
  
  8.     std::shared_ptr pObject; 
  
  
  
  
  9.     { 
    10. 
  
  
  
  
  10.       std::lock_guard guard(m_mutex); 
    11. 
  
  
  
  
  11.       if (!m_lObjects.empty()) 
    12. 
  
  
  
  
  12.       { 
    13. 
  
  
  
  
  13.         pObject = m_lObjects.front(); 
    14. 
  
  
  
  
  14.         m_lObjects.pop_front(); 
    15. 
  
  
  
  
  15.       } 
    16. 
  
  
  
  
  16.     } 
    17. 
  
  
  
  
  17.  
    18. 
  
  
  
  
  18.     if (!pObject) 
    19. 
  
  
  
  
  19.     { 
    20. 
  
  
  
  
  20.       pObject = std::make_shared(strInit); 
  
  
  
  
  21.     } 
    22. 
  
  
  
  
  22.     return pObject; 
    23. 
  
  
  
  
  23.   } 
    24. 
  
  
  
  
  24.  
    25. 
  
  
  
  
  25.   void ReturnObject(std::shared_ptr pObject) 
  
  
  
  
  26. { 
    27. 
  
  
  
  
  27.     if (!pObject) 
    28. 
  
  
  
  
  28.       return; 
    29. 
  
  
  
  
  29.  
    30. 
  
  
  
  
  30.     std::lock_guard guard(m_mutex); 
    31. 
  
  
  
  
  31.     m_lObjects.push_front(pObject); 
    32. 
  
  
  
  
  32.   } 
    33. 
  
  
  
  
  33.  
    34. 
  
  
  
  
  34. private: 
    35. 
  
  
  
  
  35.   std::mutex m_mutex; 
    36. 
  
  
  
  
  36.   std::list> m_lObjects; 
    37. 
  
  
  
  
  37. }; 
    38. 
 
 
 
 
    那么使用起来比较简单，如下所示。
     
 
 
 
      
  
  
  
  
    1. ObjectPool objPool; 
      2. 
  
  
  
  
    2.   auto pObj1 = objPool.GetObject("abc"); 
      3. 
  
  
  
  
    3.   //操作对象完成任务 
      4. 
  
  
  
  
    4.   //...... 
      5. 
  
  
  
  
    5.   objPool.ReturnObject(pObj1); 
      6. 
 
 
 
 
    但是要注意一点，有时候可能使用完了，却忘记调用ReturnObject了，这个时候是否想起了RAII技术《C++ RAII实现golang的defer》和《从lock_guard来说一说C++常用的RAII》。
    那么问一问，可以实现一个自动回收的对象池吗?不需要调用者在对象使用完成后，手动将对象归还给对象池，并且你可能要问:
      

    1. 针对不同类型的Object，是不是可以用模板去实现更加通用的实现一个对象池
      2. 

    2. 构造函数的参数列表，也可以是任意的形式
      3. 

    

    自动回收的对象池
    

    要实现自动回收的对象池，首先要了解unique_ptr和shared_ptr都可以自定义删除器，也就是说，比如当从对象池获取到的对象是用智能指针包裹的，一般默认的删除器为delete，那我们可以自义定删除器为: 将这个对象重新放回到对象池. 代码如下:
     
 
 
 
      
  
  
  
  
    1. template 
      2. 
  
  
  
  
    2. class ObjectPool 
      3. 
  
  
  
  
    3. { 
      4. 
  
  
  
  
    4. public: 
      5. 
  
  
  
  
    5.   ObjectPool() 
      6. 
  
  
  
  
    6.   { 
      7. 
  
  
  
  
    7.     m_fObjDeleter = [&](T* pObj) { 
      8. 
  
  
  
  
    8.       if (m_bDeconstruct) 
      9. 
  
  
  
  
    9.         delete pObj; 
      10. 
  
  
  
  
    10.       else 
      11. 
  
  
  
  
    11.       { 
      12. 
  
  
  
  
    12.         std::lock_guard guard(m_mutex); 
      13. 
  
  
  
  
    13.         m_lObjects.push_front(std::shared_ptr(pObj, m_fObjDeleter)); 
      14. 
  
  
  
  
    14.       } 
      15. 
  
  
  
  
    15.     }; 
      16. 
  
  
  
  
    16.   } 
      17. 
  
  
  
  
    17.  
      18. 
  
  
  
  
    18.   ~ObjectPool() 
      19. 
  
  
  
  
    19.   { 
      20. 
  
  
  
  
    20.     m_bDeconstruct = true; 
      21. 
  
  
  
  
    21.   } 
      22. 
  
  
  
  
    22.  
      23. 
  
  
  
  
    23.   template 
      24. 
  
  
  
  
    24.   std::shared_ptr GetObject(Args&&... args) 
      25. 
  
  
  
  
    25.   { 
      26. 
  
  
  
  
    26.     std::shared_ptr pObject; 
      27. 
  
  
  
  
    27.     { 
      28. 
  
  
  
  
    28.       std::lock_guard guard(m_mutex); 
      29. 
  
  
  
  
    29.       if (!m_lObjects.empty()) 
      30. 
  
  
  
  
    30.       { 
      31. 
  
  
  
  
    31.         pObject = m_lObjects.front(); 
      32. 
  
  
  
  
    32.         m_lObjects.pop_front(); 
      33. 
  
  
  
  
    33.       } 
      34. 
  
  
  
  
    34.     } 
      35. 
  
  
  
  
    35.  
      36. 
  
  
  
  
    36.     if (!pObject) 
      37. 
  
  
  
  
    37.     { 
      38. 
  
  
  
  
    38.       pObject.reset(new T(std::forward(args)...), m_fObjDeleter); 
      39. 
  
  
  
  
    39.     } 
      40. 
  
  
  
  
    40.     return pObject; 
      41. 
  
  
  
  
    41.   } 
      42. 
  
  
  
  
    42.  
      43. 
  
  
  
  
    43.   void ReturnObject(std::shared_ptr pObject) 
      44. 
  
  
  
  
    44. { 
      45. 
  
  
  
  
    45.     if (!pObject) 
      46. 
  
  
  
  
    46.       return; 
      47. 
  
  
  
  
    47.  
      48. 
  
  
  
  
    48.     std::lock_guard guard(m_mutex); 
      49. 
  
  
  
  
    49.     m_lObjects.push_front(pObject); 
      50. 
  
  
  
  
    50.   } 
      51. 
  
  
  
  
    51.  
      52. 
  
  
  
  
    52. private: 
      53. 
  
  
  
  
    53.   std::function m_fObjDeleter; 
      54. 
  
  
  
  
    54.   std::mutex m_mutex; 
      55. 
  
  
  
  
    55.   std::list> m_lObjects; 
      56. 
  
  
  
  
    56.   volatile bool m_bDeconstruct = false; 
      57. 
  
  
  
  
    57. }; 
      58. 
 
 
 
 
    

    自动回收
    

    关于自动回收，这个涉及到一个问题，是用unique_ptr还是shared_ptr呢，在这篇大牛写的文章中进行了比较详细的阐述《thinking in object pool》(链接见参考部分), 说明了应该使用unique_ptr，也看到不少人在网上转发。主要如下阐述：
    因为我们需要把智能指针的默认删除器改为自定义删除器，用shared_ptr会很不方便，因为你无法直接将shared_ptr的删除器修改为自定义删除器，虽然你可以通过重新创建一个新对象，把原对象拷贝过来的做法来实现，但是这样做效率比较低。而unique_ptr由于是独占语义，提供了一种简便的方法方法可以实现修改删除器，所以用unique_ptr是最适合的。
    …
    这种方式需要每次都创建一个新对象，并且拷贝原来的对象，是一种比较低效的做法。
    但本人自己进行了思考，认为可以做到使用shared_ptr一样实现了高效的自动回收机制。首先定义了一个m_fObjDeleter自定义deleter, 不过这种做法可能比较难理解一些，就是定义的m_fObjDeleter函数内也会调用m_fObjDeleter。当shared_ptr引用计数为0的时候，会做如下事情:
      

    • 如果发现是OjbectPool调用了析构函数，则直接释放对象
      • 

    • 如果发现OjbectPool并没有调用析构函数，则将对象放入对象池中
      • 

    

     
 
 
 
      
  
  
  
  
    1. m_fObjDeleter = [&](T* pObj) { 
      2. 
  
  
  
  
    2.   if (m_bDeconstruct) 
      3. 
  
  
  
  
    3.     delete pObj; 
      4. 
  
  
  
  
    4.   else 
      5. 
  
  
  
  
    5.   { 
      6. 
  
  
  
  
    6.     std::lock_guard guard(m_mutex); 
      7. 
  
  
  
  
    7.     m_lObjects.push_front(std::shared_ptr(pObj, m_fObjDeleter)); 
      8. 
  
  
  
  
    8.   } 
      9. 
  
  
  
  
    9. }; 
      10. 
 
 
 
 
    当创建对象的时候指定自定义的deleter：
     
 
 
 
      
  
  
  
  
    1. pObject.reset(new T(std::forward(args)...), m_fObjDeleter); 
      2. 
 
 
 
 
    

    模板支持
    

    使用了模板可以支持通用的对象：
     
 
 
 
      
  
  
  
  
    1. template 
      2. 
  
  
  
  
    2. class ObjectPool 
      3. 
  
  
  
  
    3. { 
      4. 
  
  
  
  
    4. public: 
      5. 
  
  
  
  
    5.     //...... 
      6. 
  
  
  
  
    6.     template 
      7. 
  
  
  
  
    7.     std::shared_ptr GetObject(Args&&... args) 
      8. 
  
  
  
  
    8.     { 
      9. 
  
  
  
  
    9.         //...... 
      10. 
  
  
  
  
    10.     } 
      11. 
  
  
  
  
    11.  
      12. 
  
  
  
  
    12.     void ReturnObject(std::shared_ptr pObject) 
      13. 
  
  
  
  
    13.     { 
      14. 
  
  
  
  
    14.         //...... 
      15. 
  
  
  
  
    15.     } 
      16. 
  
  
  
  
    16.  
      17. 
  
  
  
  
    17. private: 
      18. 
  
  
  
  
    18.     std::function m_fObjDeleter; 
      19. 
  
  
  
  
    19.     //..... 
      20. 
  
  
  
  
    20.     std::list> m_lObjects; 
      21. 
  
  
  
  
    21.     //....... 
      22. 
  
  
  
  
    22. }; 
      23. 
 
 
 
 
    

    可变函数参数完美转发
    

    不同的对象，可能使用的构造函数参数也不同，那么当调用GetObject的时候的参数要设置为可变参数，其实现如下:
     
 
 
 
      
  
  
  
  
    1. template 
      2. 
  
  
  
  
    2. std::shared_ptr GetObject(Args&&... args) 
      3. 
  
  
  
  
    3. { 
      4. 
  
  
  
  
    4.   std::shared_ptr pObject; 
      5. 
  
  
  
  
    5.   { 
      6. 
  
  
  
  
    6.     std::lock_guard guard(m_mutex); 
      7. 
  
  
  
  
    7.     if (!m_lObjects.empty()) 
      8. 
  
  
  
  
    8.     { 
      9. 
  
  
  
  
    9.       pObject = m_lObjects.front(); 
      10. 
  
  
  
  
    10.       m_lObjects.pop_front(); 
      11. 
  
  
  
  
    11.     } 
      12. 
  
  
  
  
    12.   } 
      13. 
  
  
  
  
    13.  
      14. 
  
  
  
  
    14.   if (!pObject) 
      15. 
  
  
  
  
    15.   { 
      16. 
  
  
  
  
    16.     pObject.reset(new T(std::forward(args)...), m_fObjDeleter); 
      17. 
  
  
  
  
    17.   } 
      18. 
  
  
  
  
    18.   return pObject; 
      19. 
  
  
  
  
    19. } 
      20. 
 
 
 
 
    

    其他
    

    以上对对象池的基本内容进行了阐述，那么对于对象池的实现要根据场景还有若干的细节，有些还比较重要:
      

    • 是否要在启动的时候初始化指定数量的对象?
      • 

    • 对象池的数量是否要设置一个上限或者下线
      • 

    • 对象池重复利用，当取出来后要注意，是不是要对对象做一次reset之类的操作，防止对象上一次的调用残留数据对本地调用构成影响，这个要根据自己对象的特点去进行相应的reset操作
      • 

    • 有时候当这个对象可能出现了特别的情况需要销毁，是否也需要考虑到?
      • 

    • 等等
      • 

    

    参考
      

    • <>模板部分
      • 

    • << thinking in object pool >>： https://www.cnblogs.com/qicosmos/p/4995248.html
      • 

    
            
    
                网页标题：对象池的使用场景以及自动回收技术
                
    
                URL网址：http://www.shufengxianlan.com/qtweb/news3/406303.html
            
    
            
    
                网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
    
            
    
                广告
                
            
    
            
    
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                创新互联
            
    
        
        
    
            
    猜你还喜欢下面的内容
    
            
        
    
    
    
    
        
    
            
    品牌网站制作知识
    
            
        
    
        
    
            
    分类信息网站
    
            
        
    
    
    


    
    
    
        服务器托管　　 　网站改版　　 　成都路面机械设备　　 　成都网站建设报价　　 　四川雅安服务器托管　　 　彭山网站制作　　 　手机网站制作　　 　成都工装公司　　 　梓潼做网站　　 　成都酒店服定制　　 　成都钢筋机械设备　　 　做手机网站　　 　网站推广优化　　 　水泥基自流平　　 　成都口碑营销公司　　 　网站排名优化　　 　网络口碑营销　　 　成都棕树机房　　 　钢筋机械设备　　 　四川成都网站制作