2. 程式人生 > >記憶體池——第一章 幾種常用的記憶體池技術

記憶體池——第一章 幾種常用的記憶體池技術

阿新 • • 發佈：2019-01-04
  1. #define EXTRA_BUFFER_SIZE        64
  2. namespace easy
  3. {
  4.     template<class _Type,class _Alloc >
  5.     class EasyRingbuffer 
  6.     {
  7.     public:
  8.         typedef _Alloc allocator_type;
  9.         explicit EasyRingbuffer(size_t size):
  10.         size_(size),
  11.             wpos_(
    0),
  12.             rpos_(0)
  13.         {
  14.             buffer_ = _allocate(size_);
  15.         }
  16.         ~EasyRingbuffer() { _deallocate(buffer_,size_); }
  17.         template<typename T> void append(T val) 
  18.         { 
  19.             append((easy_uint8*)&val,sizeof(val));
  20.         }

  21.         void append(const easy_uint8* src, size_t cnt)
  22.         {
  23.             if (!cnt)
  24.             {
  25.                 return;
  26.             }
  27.             //    case 1: rpos_ <= wpos_
  28.             if (rpos_ <= wpos_)
  29.             {
  30.                 if (size_ - wpos_ >
    = cnt)
  31.                 {
  32.                     memmove(buffer_ + wpos_,src,cnt);
  33.                     wpos_ += cnt;
  34.                     return;
  35.                 }
  36.                 else
  37.                 {
  38.                     if (size_ - wpos_ + rpos_ > cnt)    // >= is ok>
  39.                     {
  40.                         memmove(buffer_ + wpos_, src, size_ - wpos_);
  41.                         memmove(buffer_, src + size_ - wpos_, cnt - (size_ - wpos_));
  42.                         wpos_ = cnt - (size_ - wpos_);
  43.                         return;
  44.                     }
  45.                     else
  46.                     {
  47.                         _Type* new_buffer = _allocate(size_ + cnt - (size_ - wpos_));
  48.                         memmove(new_buffer,buffer_,wpos_);
  49.                         memmove(new_buffer + wpos_, src, cnt);
  50.                         _deallocate(buffer_,size_);
  51.                         size_ = size_ + cnt - (size_ - wpos_);
  52.                         wpos_ += cnt;
  53.                         buffer_ = new_buffer;
  54.                         return;
  55.                     }
  56.                 }
  57.             }
  58.             //    case 2: rpos_ > wpos_ 
  59.             else if(rpos_ > wpos_)
  60.             {
  61.                 if (rpos_ - wpos_ > cnt)    // >= is ok ?
  62.                 {
  63.                     if (rpos_ - wpos_ > cnt)
  64.                     {
  65.                         memmove(buffer_ + wpos_,src,cnt);
  66.                         wpos_ += cnt;
  67.                         return;
  68.                     }
  69.                     else
  70.                     {
  71.                         _Type* new_buffer = _allocate(size_ + cnt - (rpos_ - wpos_) + EXTRA_BUFFER_SIZE);
  72.                         memmove(new_buffer,buffer_,wpos_);
  73.                         memmove(new_buffer + wpos_,src,cnt);
  74.                         memmove(new_buffer + wpos_ + cnt - (rpos_ - wpos_) + EXTRA_BUFFER_SIZE,buffer_ + rpos_,size_ - rpos_);
  75.                         _deallocate(buffer_,size_);
  76.                         rpos_ += cnt - (rpos_ - wpos_) + EXTRA_BUFFER_SIZE;
  77.                         wpos_ += cnt;
  78.                         size_ = size_ + cnt - (rpos_ - wpos_) + EXTRA_BUFFER_SIZE;
  79.                         buffer_ = new_buffer;
  80.                         return;
  81.                     }
  82.                 }
  83.             }
  84.         }
  85.         EasyRingbuffer& operator << (easy_bool val)
  86.         {
  87.             append<easy_bool>(val);
  88.             return *this;
  89.         }
  90.         EasyRingbuffer& operator << (easy_uint8 val)
  91.         {
  92.             append<easy_uint8>(val);
  93.             return *this;
  94.         }
  95.         EasyRingbuffer& operator << (easy_uint16 val)
  96.         {
  97.             append<easy_uint16>(val);
  98.             return *this;
  99.         }
  100.         EasyRingbuffer& operator << (easy_uint32 val)
  101.         {
  102.             append<easy_uint32>(val);
  103.             return *this;
  104.         }
  105.         EasyRingbuffer& operator << (easy_uint64 val)
  106.         {
  107.             append<easy_uint64>(val);
  108.             return *this;
  109.         }
  110.         EasyRingbuffer& operator << (easy_int8 val)
  111.         {
  112.             append<easy_int8>(val);
  113.             return *this;
  114.         }
  115.         EasyRingbuffer& operator << (easy_int16 val)
  116.         {
  117.             append<easy_int16>(val);
  118.             return *this;
  119.         }
  120.         EasyRingbuffer& operator << (easy_int32 val)
  121.         {
  122.             append<easy_int32>(val);
  123.             return *this;
  124.         }
  125.         EasyRingbuffer& operator << (easy_int64 val)
  126.         {
  127.             append<easy_int64>(val);
  128.             return *this;
  129.         }
  130.         EasyRingbuffer& operator << (easy_float val)
  131.         {
  132.             append<easy_float>(val);
  133.             return *this;
  134.         }
  135.         EasyRingbuffer& operator << (easy_double val)
  136.         {
  137.             append<easy_double>(val);
  138.             return *this;
  139.         }
  140.         EasyRingbuffer& operator << (const std::string& val)
  141.         {
  142.             append((easy_uint8 const*)val.c_str(),val.length());
  143.             return *this;
  144.         }
  145.         EasyRingbuffer& operator << (const char* val)
  146.         {
  147.             append((easy_uint8 const *)val, val ? strlen(val) : 0);
  148.             return *this;
  149.         }
  150.         template<typename T> T read() 
  151.         {
  152.             T r;
  153.             read((easy_uint8*)&r,sizeof(T));
  154.             return r;
  155.         }
  156.         void read(easy_uint8* des,size_t len)
  157.         {
  158.             if (_read_finish())
  159.             {
  160.                 return;
  161.             }
  162.             if (rpos_ < wpos_)
  163.             {
  164.                 if (wpos_ - rpos_ >= len)
  165.                 {
  166.                     memmove(des,buffer_ + rpos_,len);

  167. 相關推薦

    記憶體池——第一章 幾種常用的記憶體池技術

    #define EXTRA_BUFFER_SIZE        64 namespace easy {     template<class _Type,class _Alloc >     class EasyRingbuffer      {   

    幾種常用記憶體管理底層介紹

    需求 系統的實體記憶體是有限的，而對記憶體的需求是變化的, 程式的動態性越強，記憶體管理就越重要，選擇合適的記憶體管理演算法會帶來明顯的效能提升。 比如nginx， 它在每個連線accept後會malloc一塊記憶體，作為整個連線生命週期內的記憶體池。 當HTTP請求

    Spring下配置幾種常用連線池

    1、連線池概述 　　資料庫連線是一種關鍵的有限的昂貴的資源，這一點在多使用者的網頁應用程式中體現得尤為突出。對資料庫連線的管理能顯著影響到整個 應用程式的伸縮性和健壯性，影響到程式的效能指標。資料庫連線池正是針對這個問題提出來的。 　　資料庫連線池負責分配、管理和釋放資料

    如何避免記憶體洩漏、溢位的幾種常用方法

    儘早釋放無用物件的引用。 好的辦法是使用臨時變數的時候，讓引用變數在退出活動域後自動設定為null，暗示垃圾收集器來收集該物件，防止發生記憶體洩露。 程式進行字串處理時，儘量避免使用String，而應使用StringBuffer。 因為每一個String物

    Spring下配置幾種常用連接池

    擴展 ade 不能 bcp thread helper facade 後者 lis 1、連接池概述　　數據庫連接是一種關鍵的有限的昂貴的資源，這一點在多用戶的網頁應用程序中體現得尤為突出。對數據庫連接的管理能顯著影響到整個應用程序的伸縮性和健壯性，影響到程序的性能指標。數據

    Java常用的幾種線程池

    fin cep read out fixed 重新 stat 支持 con 常用的幾種線程池 5.1 newCachedThreadPool 創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。 這種類型的線程池特點是： 工作線程

    Java 中幾種常用的線程池

    需要 表示 ali adf data future rate 並發 ng- Java 中幾種常用的線程池 轉載 ： https://www.cnblogs.com/sachen/p/7401959.html 原創 2016年04月14日 23:29:01 標簽： j

    linux中幾種共享記憶體

    共享記憶體用處 使用檔案或者管道進行程序間通訊會有很多侷限性。管道只能在父程序和子程序間使用；通過檔案共享，在處理效率上又差一些，而且訪問檔案描述符不如訪問記憶體地址方便。 Linux系統在程式設計上提供的共享記憶體方案有三種： mmap記憶體共享對映 XSI共享記憶體

    執行緒池實現原理（Executor框架），java提供常用的幾種執行緒池、死鎖產生條件和避免

     為什麼使用執行緒池 伺服器應用程式中經常出現的情況是：單個任務處理的時間很短而請求的數目卻是巨大的。如果每個請求對應一個執行緒（thread-per-request）方法的不足之一是：為每個請求建立一個新執行緒的開銷很大；為每個請求建立新執行緒的伺服器在建立和銷燬執行緒上

    第一章 深入理解jvm記憶體模型

    java的記憶體模型 一.執行時資料區域 java虛擬機器在程式執行時會建立不同的執行時資料區，有的區域會隨著虛擬機器啟動而存在，有的會隨著使用者執行緒存在而建立，jvm記憶體模型分為下面具體五部分： 1.程式計數器 程式技術器是較小的一塊記憶體區域，可以看

    幾種快取記憶體演算法

    快取是在CPU和記憶體之間的一塊存取速度極快的儲存單元，CPU在處理資料時，如果在暫存器中找不到目標資料，則優先從快取中尋找。而快取的容量遠遠小於記憶體的容量，當快取已滿而又要繼續往其中新增新的資料的時候，如何替換快取中已有的資料就是快取記憶體演算法要解決的問題。假設CPU

    python建立子程序的幾種常用方式（fork, Process,程序池）

    linux下使用fork()建立子程序 Linux 作業系統提供了一個 fork() 函式用來建立子程序，這個函式很特殊，呼叫一次，返回兩次，因為作業系統是將當前的程序（父程序）複製了一份（子程序），然後分別在父程序和子程序內返回。子程序永遠返回0，而父程

    幾種常用的執行緒池threadpool

    我們知道一個系統一般不可能只有一個執行緒，而根據系統的伺服器等硬體水平，我們可以合理的利用多執行緒來快速的完成我們所需要的功能。而對於系統而言，如果頻繁的建立和銷燬執行緒，也會給系統帶來相當大的負擔，所以我們平時都是利用執行緒池來解決這一點。執行緒池的作用：1）減少建立和銷燬

    JVM歷險記第一章：初到記憶體

    我是一個初次來到記憶體的資料，我被java程式輸送到此。來到記憶體後我很迷茫，因為不知道應該到哪去，看起來好像有五個部落。PC暫存器部落：它說它只接受它親戚執行緒的資料，沒有私下關係根本不讓進。人家的名

    記憶體分頁的幾種方法

    目錄 第一種：直接取分頁資料 /** * 處理記憶體分頁 * @param list * @param pageNo * @param pageSize * @return */ private <T> L

    java 中幾種常用數據結構

    初學 ble log app 使用 blog list 好的 sort Java中有幾種常用的數據結構，主要分為Collection和map兩個主要接口（接口只提供方法，並不提供實現），而程序中最終使用的數據結構是繼承自這些接口的數據結構類。 一、幾個常用類的區別 1．

    幾種常用的空格

    idt 而且 根據 筆記本 p s 時也 引用 其中 等等 今天上午把在家寫好的代碼下載到另一個筆記本上，一調試發現，出現的結果和之前不一樣。我用代碼寫好的等腰三角形，在家調試完成沒有任何問 題。在這臺筆記本上顯示成了直角三角形。仔細檢查了下，代碼並沒有發現什麽問

    C#中幾種常用的集合的用法

    col div tex -c 組成 相同 列表 對象 count 集合:將一推數據類型相同的數據放入到一個容器內，該容器就是數組：內存中開辟的一連串空間。 非泛型集合 ArrayList集合： ArrayList是基於數組實現的，是一個動態數組，其容量能自動 增

    SSH免登陸ESXI讓操作更便捷安全（幾種常用工具）

    esxi vmware ssh工具 免登陸 授權訪問通常在企業環境中，管理員很少去機房在物理機面前進行操作，大部分管理員喜歡遠程管理主機，這樣既方便又高效。在windows上我們使用遠程桌面，在Linux上則使用SSH來連接。ESXi就是一個以Linux為核心改寫的操作系統，因此ESXi中也保留了SSH

    JAVA獲取文件的幾種常用方式

    ada col epo term 打印 core book port nbsp 1、user.dir System.out.println(System.getProperty("user.dir")); 此方獲取的是運行的路 比如 1、 2、如果在eclipse上運