![\"9efbcbc3d25747719da38c01b3fa9b4f.gif\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/01\/20260128143258-697a1e1ad5fcc.gif\")
<\/p>\n🌈\u4e2a\u4eba\u4e3b\u9875：\u79e6jh__https:\/\/blog.csdn.net\/qinjh_?spm=1010.2135.3001.5343 🔥\u00a0\u7cfb\u5217\u4e13\u680f：https:\/\/blog.csdn.net\/qinjh_\/category_13016668.html<\/p>\n
\u00a0\u00a0<\/p>\n
\u76ee\u5f55<\/p>\n
\u4ece\u96f6\u5b9e\u73b0\u4e00\u4e2a\u9ad8\u5e76\u53d1\u5185\u5b58\u6c60<\/p>\n
\u9879\u76ee\u4ecb\u7ecd<\/p>\n
\u8fd9\u4e2a\u9879\u76ee\u505a\u7684\u662f\u4ec0\u4e48？\u00a0<\/p>\n
\u4ec0\u4e48\u662f\u5185\u5b58\u6c60\u00a0<\/p>\n
1.\u6c60\u5316\u6280\u672f\u00a0<\/p>\n
2.\u5185\u5b58\u6c60\u00a0<\/p>\n
3.\u5185\u5b58\u6c60\u4e3b\u8981\u89e3\u51b3\u7684\u95ee\u9898\u00a0<\/p>\n
\u00a04.malloc<\/p>\n
\u5f00\u80c3\u83dc–\u5148\u8bbe\u8ba1\u4e00\u4e2a\u5b9a\u957f\u7684\u5185\u5b58\u6c60\u00a0<\/p>\n
\u9ad8\u5e76\u53d1\u5185\u5b58\u6c60\u6574\u4f53\u6846\u67b6\u8bbe\u8ba1<\/p>\n
\u9ad8\u5e76\u53d1\u5185\u5b58\u6c60–thread cache\u00a0<\/p>\n
\u9ad8\u5e76\u53d1\u5185\u5b58\u6c60–central cache<\/p>\n
\u00a0\u9ad8\u5e76\u53d1\u5185\u5b58\u6c60–page cache<\/p>\n
\u2002\u2002\u2002\u2002💬 hello! \u5404\u4f4d\u94c1\u5b50\u4eec\u5927\u5bb6\u597d\u54c7\u3002<\/p>\n
\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0\u4eca\u65e5\u66f4\u65b0\u4e86\u9ad8\u5e76\u53d1\u5185\u5b58\u6c60\u7684\u5185\u5bb9 \u2002\u2002\u2002\u2002🎉 \u6b22\u8fce\u5927\u5bb6\u5173\u6ce8🔍\u70b9\u8d5e👍\u6536\u85cf\u2b50\ufe0f\u7559\u8a00📝<\/p>\n<\/p>\n
\u5f53\u524d\u9879\u76ee\u662f\u5b9e\u73b0\u4e00\u4e2a\u9ad8\u5e76\u53d1\u7684\u5185\u5b58\u6c60，\u4ed6\u7684\u539f\u578b\u662fgoogle\u7684\u4e00\u4e2a\u5f00\u6e90\u9879\u76eetcmalloc，tcmalloc\u5168\u79f0 Thread-Caching Malloc，\u5373\u7ebf\u7a0b\u7f13\u5b58\u7684malloc，\u5b9e\u73b0\u4e86\u9ad8\u6548\u7684\u591a\u7ebf\u7a0b\u5185\u5b58\u7ba1\u7406，\u7528\u4e8e\u66ff\u4ee3\u7cfb\u7edf\u7684\u5185\u5b58 \u5206\u914d\u76f8\u5173\u7684\u51fd\u6570（malloc\u3001free）\u3002<\/p>\n
\u8fd9\u4e2a\u9879\u76ee\u662f\u628atcmalloc\u6700\u6838\u5fc3\u7684\u6846\u67b6\u7b80\u5316\u540e\u62ff\u51fa\u6765，\u6a21\u62df\u5b9e\u73b0\u51fa\u4e00\u4e2a\u81ea\u5df1\u7684\u9ad8\u5e76\u53d1\u5185\u5b58\u6c60，\u76ee\u7684\u5c31 \u662f\u5b66\u4e60tcamlloc\u7684\u7cbe\u534e\u3002<\/p>\n
\u6240\u8c13\u201c\u6c60\u5316\u6280\u672f\u201d，\u5c31\u662f\u7a0b\u5e8f\u5148\u5411\u7cfb\u7edf\u7533\u8bf7\u8fc7\u91cf\u7684\u8d44\u6e90，\u7136\u540e\u81ea\u5df1\u7ba1\u7406，\u4ee5\u5907\u4e0d\u65f6\u4e4b\u9700\u3002\u4e4b\u6240\u4ee5\u8981\u7533\u8bf7\u8fc7 \u91cf\u7684\u8d44\u6e90，\u662f\u56e0\u4e3a\u6bcf\u6b21\u7533\u8bf7\u8be5\u8d44\u6e90\u90fd\u6709\u8f83\u5927\u7684\u5f00\u9500，\u4e0d\u5982\u63d0\u524d\u7533\u8bf7\u597d\u4e86，\u8fd9\u6837\u4f7f\u7528\u65f6\u5c31\u4f1a\u53d8\u5f97\u975e\u5e38\u5feb \u6377，\u5927\u5927\u63d0\u9ad8\u7a0b\u5e8f\u8fd0\u884c\u6548\u7387\u3002\u00a0<\/p>\n
\u00a0\u5728\u8ba1\u7b97\u673a\u4e2d，\u6709\u5f88\u591a\u4f7f\u7528\u201c\u6c60\u201d\u8fd9\u79cd\u6280\u672f\u7684\u5730\u65b9，\u9664\u4e86\u5185\u5b58\u6c60，\u8fd8\u6709\u8fde\u63a5\u6c60\u3001\u7ebf\u7a0b\u6c60\u3001\u5bf9\u8c61\u6c60\u7b49\u3002\u4ee5\u670d\u52a1 \u5668\u4e0a\u7684\u7ebf\u7a0b\u6c60\u4e3a\u4f8b，\u5b83\u7684\u4e3b\u8981\u601d\u60f3\u662f：\u5148\u542f\u52a8\u82e5\u5e72\u6570\u91cf\u7684\u7ebf\u7a0b，\u8ba9\u5b83\u4eec\u5904\u4e8e\u7761\u7720\u72b6\u6001，\u5f53\u63a5\u6536\u5230\u5ba2\u6237\u7aef \u7684\u8bf7\u6c42\u65f6，\u5524\u9192\u6c60\u4e2d\u67d0\u4e2a\u7761\u7720\u7684\u7ebf\u7a0b，\u8ba9\u5b83\u6765\u5904\u7406\u5ba2\u6237\u7aef\u7684\u8bf7\u6c42，\u5f53\u5904\u7406\u5b8c\u8fd9\u4e2a\u8bf7\u6c42，\u7ebf\u7a0b\u53c8\u8fdb\u5165\u7761\u7720 \u72b6\u6001\u3002<\/p>\n
\u5185\u5b58\u6c60\u662f\u6307\u7a0b\u5e8f\u9884\u5148\u4ece\u64cd\u4f5c\u7cfb\u7edf\u7533\u8bf7\u4e00\u5757\u8db3\u591f\u5927\u5185\u5b58，\u6b64\u540e，\u5f53\u7a0b\u5e8f\u4e2d\u9700\u8981\u7533\u8bf7\u5185\u5b58\u7684\u65f6\u5019，\u4e0d\u662f\u76f4\u63a5 \u5411\u64cd\u4f5c\u7cfb\u7edf\u7533\u8bf7，\u800c\u662f\u76f4\u63a5\u4ece\u5185\u5b58\u6c60\u4e2d\u83b7\u53d6；\u540c\u7406，\u5f53\u7a0b\u5e8f\u91ca\u653e\u5185\u5b58\u7684\u65f6\u5019，\u5e76\u4e0d\u771f\u6b63\u5c06\u5185\u5b58\u8fd4\u56de\u7ed9\u64cd \u4f5c\u7cfb\u7edf，\u800c\u662f\u8fd4\u56de\u5185\u5b58\u6c60\u3002\u5f53\u7a0b\u5e8f\u9000\u51fa(\u6216\u8005\u7279\u5b9a\u65f6\u95f4)\u65f6，\u5185\u5b58\u6c60\u624d\u5c06\u4e4b\u524d\u7533\u8bf7\u7684\u5185\u5b58\u771f\u6b63\u91ca\u653e\u3002\u00a0<\/p>\n
\u5185\u5b58\u6c60\u4e3b\u8981\u89e3\u51b3\u7684\u5f53\u7136\u662f\u6548\u7387\u7684\u95ee\u9898，\u5176\u6b21\u5982\u679c\u4f5c\u4e3a\u7cfb\u7edf\u7684\u5185\u5b58\u5206\u914d\u5668\u7684\u89d2\u5ea6，\u8fd8\u9700\u8981\u89e3\u51b3\u4e00\u4e0b\u5185\u5b58\u788e \u7247\u7684\u95ee\u9898\u3002\u90a3\u4e48\u4ec0\u4e48\u662f\u5185\u5b58\u788e\u7247\u5462？\u00a0<\/p>\n
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/01\/20260128143258-697a1e1ae7ff9.png\")
\u200b<\/p>\n
\u518d\u9700\u8981\u8865\u5145\u8bf4\u660e\u7684\u662f\u5185\u5b58\u788e\u7247\u5206\u4e3a\u5916\u788e\u7247\u548c\u5185\u788e\u7247，\u4e0a\u9762\u6211\u4eec\u8bb2\u7684\u5916\u788e\u7247\u95ee\u9898\u3002\u5916\u90e8\u788e\u7247\u662f\u4e00\u4e9b\u7a7a\u95f2\u7684\u8fde\u7eed\u5185\u5b58\u533a\u57df\u592a\u5c0f，\u8fd9\u4e9b\u5185\u5b58\u7a7a\u95f4\u4e0d\u8fde\u7eed，\u4ee5\u81f3\u4e8e\u5408\u8ba1\u7684\u5185\u5b58\u8db3\u591f，\u4f46\u662f\u4e0d\u80fd\u6ee1\u8db3\u4e00\u4e9b\u7684\u5185\u5b58\u5206\u914d\u7533\u8bf7 \u9700\u6c42\u3002\u5185\u90e8\u788e\u7247\u662f\u7531\u4e8e\u4e00\u4e9b\u5bf9\u9f50\u7684\u9700\u6c42，\u5bfc\u81f4\u5206\u914d\u51fa\u53bb\u7684\u7a7a\u95f4\u4e2d\u4e00\u4e9b\u5185\u5b58\u65e0\u6cd5\u88ab\u5229\u7528\u3002\u00a0<\/p>\n
C\/C++\u4e2d\u6211\u4eec\u8981\u52a8\u6001\u7533\u8bf7\u5185\u5b58\u90fd\u662f\u901a\u8fc7malloc\u53bb\u7533\u8bf7\u5185\u5b58，\u4f46\u662f\u6211\u4eec\u8981\u77e5\u9053，\u5b9e\u9645\u6211\u4eec\u4e0d\u662f\u76f4\u63a5\u53bb\u5806\u83b7 \u53d6\u5185\u5b58\u7684，\u800cmalloc\u5c31\u662f\u4e00\u4e2a\u5185\u5b58\u6c60\u3002malloc() \u76f8\u5f53\u4e8e\u5411\u64cd\u4f5c\u7cfb\u7edf\u201c\u6279\u53d1\u201d\u4e86\u4e00\u5757\u8f83\u5927\u7684\u5185\u5b58\u7a7a\u95f4，\u7136\u540e\u201c\u96f6\u552e\u201d\u7ed9\u7a0b \u5e8f\u7528\u3002\u5f53\u5168\u90e8\u201c\u552e\u5b8c\u201d\u6216\u7a0b\u5e8f\u6709\u5927\u91cf\u7684\u5185\u5b58\u9700\u6c42\u65f6，\u518d\u6839\u636e\u5b9e\u9645\u9700\u6c42\u5411\u64cd\u4f5c\u7cfb\u7edf\u201c\u8fdb\u8d27\u201d\u3002malloc\u7684\u5b9e\u73b0\u65b9 \u5f0f\u6709\u5f88\u591a\u79cd，\u4e00\u822c\u4e0d\u540c\u7f16\u8bd1\u5668\u5e73\u53f0\u7528\u7684\u90fd\u662f\u4e0d\u540c\u7684\u3002\u6bd4\u5982windows\u7684vs\u7cfb\u5217\u7528\u7684\u5fae\u8f6f\u81ea\u5df1\u5199\u7684\u4e00\u5957， linux gcc\u7528\u7684glibc\u4e2d\u7684ptmalloc\u00a0\u3002<\/p>\n
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/01\/20260128143259-697a1e1b44f3b.png\")
\u200b<\/p>\n
\u4f5c\u4e3a\u7a0b\u5e8f\u5458(C\/C++)\u6211\u4eec\u77e5\u9053\u7533\u8bf7\u5185\u5b58\u4f7f\u7528\u7684\u662fmalloc，malloc\u5176\u5b9e\u5c31\u662f\u4e00\u4e2a\u901a\u7528\u7684\u5927\u4f17\u8d27，\u4ec0\u4e48\u573a\u666f \u4e0b\u90fd\u53ef\u4ee5\u7528，\u4f46\u662f\u4ec0\u4e48\u573a\u666f\u4e0b\u90fd\u53ef\u4ee5\u7528\u5c31\u610f\u5473\u7740\u4ec0\u4e48\u573a\u666f\u4e0b\u90fd\u4e0d\u4f1a\u6709\u5f88\u9ad8\u7684\u6027\u80fd，\u4e0b\u9762\u6211\u4eec\u5c31\u5148\u6765\u8bbe\u8ba1 \u4e00\u4e2a\u5b9a\u957f\u5185\u5b58\u6c60\u505a\u4e2a\u5f00\u80c3\u83dc，\u5f53\u7136\u8fd9\u4e2a\u5b9a\u957f\u5185\u5b58\u6c60\u5728\u6211\u4eec\u540e\u9762\u7684\u9ad8\u5e76\u53d1\u5185\u5b58\u6c60\u4e2d\u4e5f\u662f\u6709\u4ef7\u503c\u7684，\u6240\u4ee5\u5b66 \u4e60\u4ed6\u76ee\u7684\u6709\u4e24\u5c42，\u5148\u719f\u6089\u4e00\u4e0b\u7b80\u5355\u5185\u5b58\u6c60\u662f\u5982\u4f55\u63a7\u5236\u7684，\u7b2c\u4e8c\u4ed6\u4f1a\u4f5c\u4e3a\u6211\u4eec\u540e\u9762\u5185\u5b58\u6c60\u7684\u4e00\u4e2a\u57fa\u7840\u7ec4 \u4ef6\u3002\u00a0<\/p>\n
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/01\/20260128143259-697a1e1bba4b3.png\")
\u200b![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/01\/20260128143300-697a1e1c1e597.png\")
\u200b<\/p>\n
\u00a0\u4ee3\u7801\u6837\u4f8b：<\/p>\n
ObjectPool.h<\/p>\n
template<class T>\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0
\nclass ObjectPool
\n{
\npublic:<\/p>\n
T* New()
\n{
\nT* obj = nullptr;<\/p>\n
\/\/\u4f18\u5148\u628a\u8fd8\u56de\u6765\u7684\u5185\u5b58\u5757\u5bf9\u8c61，\u518d\u6b21\u91cd\u590d\u5229\u7528
\nif (_freeList)
\n{
\nvoid* next = *((void**)_freeList); \/\/next\u662f\u81ea\u7531\u94fe\u8868\u7684\u7b2c\u4e00\u4e2a\u8282\u70b9\u7684\u5934\u56db\/\u516b\u4e2a\u5b57\u8282，\u5b83\u5b58\u653e\u4e0b\u4e00\u4e2a\u8282\u70b9\u7684\u5730\u5740
\nobj = (T*)_freeList;\/\/obj\u5c31\u662f\u7b2c\u4e00\u5757\u5185\u5b58\u5757
\n_freeList = next;\/\/\u518d\u8ba9next\u53d8\u6210\u7b2c\u4e00\u4e2a\u8282\u70b9
\n}
\nelse
\n{
\nif (_remainBytes < sizeof(T))\/\/\u5982\u679c\u5269\u4f59\u5185\u5b58\u5c0f\u4e8e\u6240\u9700\u5185\u5b58，\u5c31\u53bb\u7533\u8bf7\u5927\u5757\u7a7a\u95f4
\n{
\n_remainBytes = 128 * 1024;
\n_memory = (char*)malloc(_remainBytes);
\nif (_memory == nullptr)
\n{
\nthrow std::bad_alloc();
\n}
\n}<\/p>\n
obj = (T*)_memory;\/\/\u628a\u5927\u5757\u5185\u5b58\u5207\u6210\u5c0f\u5757，\u5206\u51fa\u53bb
\nsize_t objSize=sizeof(T)<sizeof(void*)?sizeof(void*):sizeof(T);\/\/\u4fdd\u8bc1\u81f3\u5c11\u80fd\u5b58\u653e\u4e0b\u4e00\u4e2a\u5bf9\u8c61\u7684\u5730\u5740
\n_memory += objSize;
\n_remainBytes -= objSize;
\n}<\/p>\n
\/\/malloc\u53ea\u5f00\u4e86\u7a7a\u95f4，\u6ca1\u6709\u521d\u59cb\u5316，\u8981\u8fdb\u884c\u521d\u59cb\u5316
\n\/\/\u5b9a\u4f4dnew，\u663e\u793a\u8c03\u7528T\u7684\u6784\u9020\u51fd\u6570\u521d\u59cb\u5316
\nnew(obj)T;<\/p>\n
return obj;
\n}<\/p>\n
void Delete(T* obj)
\n{
\n\/\/if (_freeList == nullptr)
\n\/\/{
\n\/\/_freeList = obj;
\n\/\/\/\/*(int*)obj=nullptr; \u5f3a\u8f6c\u6210int*\u7c7b\u578b，\u6b64\u65f6\u53ea\u80fd\u572832\u4f4d\u673a\u5668\u4e0a\u8dd1，\u56e0\u4e3a64\u4f4d\u673a\u5668\u4e0a，\u6307\u9488\u5927\u5c0f\u662f8\u5b57\u8282\u3002
\n\/\/*(void**)obj = nullptr; \/\/\u8fd9\u91cc\u4f7f\u7528\u4e8c\u7ea7\u6307\u9488\u5373\u53ef\u89e3\u51b3，void**\u89e3\u5f15\u7528\u540e，\u5c31\u662fvoid*，\u6b64\u65f6\u8fd8\u662f\u6307\u9488，\u572832\u4f4d\u673a\u5668\u4e0a\u5c31\u662f4\u5b57\u8282，\u572864\u4f4d\u673a\u5668\u4e0a\u5c31\u662f8\u5b57\u8282，\u53ef\u4ee5\u81ea\u52a8\u9002\u5e94
\n\/\/}
\n\/\/else
\n\/\/{
\n\/\/\/\/\u5934\u63d2
\n\/\/*(void**)obj = _freeList; \/\/\u5148\u8ba9\u5c0f\u5185\u5b58\u5757\u6307\u5411\u81ea\u7531\u94fe\u8868\u7684\u7b2c\u4e00\u4e2a\u8282\u70b9，\u56e0\u4e3afreeList\u6307\u5411\u7684\u5c31\u662f\u7b2c\u4e00\u4e2a\u8282\u70b9\u3002
\n\/\/_freeList = obj; \/\/\u63a5\u7740\u518d\u8ba9obj\u53d8\u6210\u7b2c\u4e00\u4e2a\u8282\u70b9，\u8ba9freelist\u6307\u5411boj\u3002
\n\/\/}<\/p>\n
\/\/\u663e\u793a\u8c03\u7528\u6790\u6784\u51fd\u6570\u6e05\u7406\u5bf9\u8c61
\nobj->~T();<\/p>\n
\/\/\u5934\u63d2
\n*(void**)obj = _freeList; \/\/\u5b9e\u9645\u4e0a\u4e0d\u9700\u8981\u533a\u5206\u60c5\u51b5，\u56e0\u4e3a\u7a7a\u7684\u65f6\u5019，\u76f4\u63a5\u5934\u63d2\u4e5f\u53ef\u4ee5
\n_freeList = obj; <\/p>\n
}<\/p>\n
private:
\nchar* _memory=nullptr;\/\/\u56e0\u4e3a\u4e00\u4e2achar\u662f\u4e00\u4e2a\u5b57\u8282，\u5207\u5185\u5b58\u5757\u65f6\u597d\u7528\u3002\u6307\u5411\u5927\u5757\u5185\u5b58\u7684\u6307\u9488
\nsize_t _remainBytes = 0;\/\/\u5927\u5757\u5185\u5b58\u5728\u5207\u5206\u8fc7\u7a0b\u4e2d\u5269\u4f59\u5b57\u8282\u6570
\nvoid* _freeList=nullptr;\/\/\u8fd8\u56de\u6765\u8fc7\u7a0b\u4e2d\u94fe\u63a5\u7684\u81ea\u7531\u94fe\u8868\u7684\u5934\u6307\u9488
\n}; <\/p>\n
\u73b0\u4ee3\u5f88\u591a\u7684\u5f00\u53d1\u73af\u5883\u90fd\u662f\u591a\u6838\u591a\u7ebf\u7a0b，\u5728\u7533\u8bf7\u5185\u5b58\u7684\u573a\u666f\u4e0b，\u5fc5\u7136\u5b58\u5728\u6fc0\u70c8\u7684\u9501\u7ade\u4e89\u95ee\u9898\u3002malloc\u672c\u8eab \u5176\u5b9e\u5df2\u7ecf\u5f88\u4f18\u79c0，\u90a3\u4e48\u6211\u4eec\u9879\u76ee\u7684\u539f\u578btcmalloc\u5c31\u662f\u5728\u591a\u7ebf\u7a0b\u9ad8\u5e76\u53d1\u7684\u573a\u666f\u4e0b\u66f4\u80dc\u4e00\u7b79，\u6240\u4ee5\u8fd9\u6b21\u6211\u4eec \u5b9e\u73b0\u7684\u5185\u5b58\u6c60\u9700\u8981\u8003\u8651\u4ee5\u4e0b\u51e0\u65b9\u9762\u7684\u95ee\u9898\u3002\u00a0<\/p>\n
concurrent memory pool\u4e3b\u8981\u7531\u4ee5\u4e0b3\u4e2a\u90e8\u5206\u6784\u6210：<\/p>\n
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/01\/20260128143300-697a1e1c483f9.png\")
\u200b<\/p>\n
thread cache\u662f\u54c8\u5e0c\u6876\u7ed3\u6784，\u6bcf\u4e2a\u6876\u662f\u4e00\u4e2a\u6309\u6876\u4f4d\u7f6e\u6620\u5c04\u5927\u5c0f\u7684\u5185\u5b58\u5757\u5bf9\u8c61\u7684\u81ea\u7531\u94fe\u8868\u3002\u6bcf\u4e2a\u7ebf\u7a0b\u90fd\u4f1a \u6709\u4e00\u4e2athread cache\u5bf9\u8c61，\u8fd9\u6837\u6bcf\u4e2a\u7ebf\u7a0b\u5728\u8fd9\u91cc\u83b7\u53d6\u5bf9\u8c61\u548c\u91ca\u653e\u5bf9\u8c61\u65f6\u662f\u65e0\u9501\u7684\u3002\u00a0<\/p>\n
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/01\/20260128143300-697a1e1ca732b.png\")
\u200b<\/p>\n
\u7533\u8bf7\u5185\u5b58：<\/p>\n
\u91ca\u653e\u5185\u5b58：\u00a0<\/p>\n
central cache\u4e5f\u662f\u4e00\u4e2a\u54c8\u5e0c\u6876\u7ed3\u6784，\u4ed6\u7684\u54c8\u5e0c\u6876\u7684\u6620\u5c04\u5173\u7cfb\u8ddfthread cache\u662f\u4e00\u6837\u7684\u3002\u4e0d\u540c\u7684\u662f\u4ed6\u7684\u6bcf \u4e2a\u54c8\u5e0c\u6876\u4f4d\u7f6e\u6302\u662fSpanList\u94fe\u8868\u7ed3\u6784，\u4e0d\u8fc7\u6bcf\u4e2a\u6620\u5c04\u6876\u4e0b\u9762\u7684span\u4e2d\u7684\u5927\u5185\u5b58\u5757\u88ab\u6309\u6620\u5c04\u5173\u7cfb\u5207\u6210\u4e86\u4e00 \u4e2a\u4e2a\u5c0f\u5185\u5b58\u5757\u5bf9\u8c61\u6302\u5728span\u7684\u81ea\u7531\u94fe\u8868\u4e2d\u3002\u00a0<\/p>\n
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/01\/20260128143301-697a1e1d21365.png\")
\u200b<\/p>\n
\u7533\u8bf7\u5185\u5b58：\u00a0<\/p>\n
\u91ca\u653e\u5185\u5b58：\u00a0<\/p>\n
\u5f53thread_cache\u8fc7\u957f\u6216\u8005\u7ebf\u7a0b\u9500\u6bc1，\u5219\u4f1a\u5c06\u5185\u5b58\u91ca\u653e\u56decentral cache\u4e2d\u7684，\u91ca\u653e\u56de\u6765\u65f6– use_count\u3002\u5f53use_count\u51cf\u52300\u65f6\u5219\u8868\u793a\u6240\u6709\u5bf9\u8c61\u90fd\u56de\u5230\u4e86span，\u5219\u5c06span\u91ca\u653e\u56depage cache， page cache\u4e2d\u4f1a\u5bf9\u524d\u540e\u76f8\u90bb\u7684\u7a7a\u95f2\u9875\u8fdb\u884c\u5408\u5e76\u3002<\/p>\n
\u7533\u8bf7\u5185\u5b58：\u00a0<\/p>\n
\u91ca\u653e\u5185\u5b58：<\/p>\n
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/01\/20260128143301-697a1e1d85837.png\")
\u200b<\/p>\n
\u7801\u4e91：https:\/\/gitee.com\/qinjianhao0\/project-warehouse\/tree\/master\/FAPool<\/p>\n
#pragma once<\/p>\n
#include"Common.h"<\/p>\n
\/\/\u5355\u4f8b\u6a21\u5f0f \u61d2\u6c49
\nclass CentralCache
\n{
\npublic:
\nstatic CentralCache* GetInstance()
\n{
\nreturn &_sInst;
\n}<\/p>\n
\/\/ \u83b7\u53d6\u4e00\u4e2a\u975e\u7a7a\u7684span
\nSpan* GetOneSpan(SpanList& list, size_t byte_size);<\/p>\n
\/\/ \u4ece\u4e2d\u5fc3\u7f13\u5b58\u83b7\u53d6\u4e00\u5b9a\u6570\u91cf\u7684\u5bf9\u8c61\u7ed9thread cache
\nsize_t FetchRangeObj(void*& start, void*& end, size_t batchNum, size_t size);<\/p>\n
\/\/ \u5c06\u4e00\u5b9a\u6570\u91cf\u7684\u5bf9\u8c61\u91ca\u653e\u5230span\u8de8\u5ea6
\nvoid ReleaseListToSpans(void* start, size_t byte_size);
\nprivate:
\nSpanList _spanLists[NFREELIST];
\nprivate:
\nCentralCache()
\n{}<\/p>\n
CentralCache(const CentralCache&) = delete;<\/p>\n
static CentralCache _sInst;
\n};<\/p>\n
#pragma once<\/p>\n
#include<iostream>
\n#include<vector>
\n#include<unordered_map>
\n#include<algorithm><\/p>\n
#include<thread>
\n#include<mutex><\/p>\n
#include<time.h>
\n#include<assert.h><\/p>\n
using std::cout;
\nusing std::endl;<\/p>\n
#ifdef _WIN32
\n#include<windows.h>
\n#else
\n\/\/…
\n#endif<\/p>\n
\/\/ \u5c0f\u4e8e\u7b49\u4e8eMAX_BYTES，\u5c31\u627ethread cache\u7533\u8bf7
\n\/\/ \u5927\u4e8eMAX_BYTES，\u5c31\u76f4\u63a5\u627epage cache\u6216\u8005\u7cfb\u7edf\u5806\u7533\u8bf7
\nstatic const size_t MAX_BYTES = 256 * 1024;
\nstatic const size_t NFREELIST = 208;\/\/ thread cache \u548c central cache\u81ea\u7531\u94fe\u8868\u54c8\u5e0c\u6876\u7684\u8868\u5927\u5c0f\u3002thread cache\u4e2d\u6876\u7684\u4e2a\u6570，\u4e5f\u5c31\u662f\u81ea\u7531\u94fe\u8868\u7684\u4e2a\u6570\u662f208\u3002
\nstatic const size_t NPAGES = 129;
\nstatic const size_t PAGE_SHIFT = 13; \/\/ <<PAGE_SHIFT \u8868\u793a\u4e58\u4ee58k\u7684\u5927\u5c0f\u3002\u9875\u5927\u5c0f\u8f6c\u6362\u504f\u79fb, \u5373\u4e00\u9875\u5b9a\u4e49\u4e3a2^13,\u4e5f\u5c31\u662f8KB<\/p>\n
#ifdef _WIN64
\ntypedef unsigned long long PAGE_ID; \/\/64\u4f4d\u4e0b8\u5b57\u8282
\n#elif _WIN32\/\/32\u4f4d\u4e0b4\u5b57\u8282
\ntypedef size_t PAGE_ID;
\n#else
\n\/\/linux
\n#endif <\/p>\n
\/\/ \u76f4\u63a5\u53bb\u5806\u4e0a\u6309\u9875\u7533\u8bf7\u7a7a\u95f4
\ninline static void* SystemAlloc(size_t kpage)
\n{
\n#ifdef _WIN32
\nvoid* ptr = VirtualAlloc(0, kpage * (1 << 12), MEM_COMMIT | MEM_RESERVE,
\nPAGE_READWRITE);
\n#else
\n\/\/ linux\u4e0bbrk mmap\u7b49
\n#endif
\nif (ptr == nullptr)
\nthrow std::bad_alloc();
\nreturn ptr;
\n}<\/p>\n
inline static void SystemFree(void* ptr)
\n{
\n#ifdef _WIN32
\nVirtualFree(ptr, 0, MEM_RELEASE);
\n#else
\n\/\/ sbrk unmmap\u7b49
\n#endif
\n}<\/p>\n
\/\/ \u83b7\u53d6\u5185\u5b58\u5bf9\u8c61\u4e2d\u5b58\u50a8\u7684\u59344 or 8\u5b57\u8282\u503c，\u5373\u94fe\u63a5\u7684\u4e0b\u4e00\u4e2a\u5bf9\u8c61\u7684\u5730\u5740
\nstatic void*& NextObj(void* obj)\/\/\u8fd4\u56de\u5f15\u7528\u540e，\u5c31\u53ef\u4ee5\u8d4b\u503c
\n{
\nreturn *(void**)obj;
\n}<\/p>\n
\/\/\u7ba1\u7406\u5207\u5206\u597d\u7684\u5c0f\u5bf9\u8c61\u7684\u81ea\u7531\u94fe\u8868
\nclass FreeList
\n{
\npublic:
\nvoid Push(void* obj)
\n{
\nassert(obj);<\/p>\n
\/\/\u5934\u63d2
\n\/\/*(void**)obj = _freeList;
\nNextObj(obj) = _freeList;
\n_freeList = obj;<\/p>\n
++_size;
\n}<\/p>\n
void PushRange(void* start, void* end,size_t n)
\n{
\nNextObj(end) = _freeList;
\n_freeList = start;<\/p>\n
_size += n;
\n}<\/p>\n
void PopRange(void*& start, void*& end, size_t n)
\n{
\nassert(n >= _size);
\nstart = _freeList;
\nend = start;<\/p>\n
for (size_t i = 0; i < n – 1; i++)
\n{
\nend = NextObj(end);
\n}<\/p>\n
_freeList = NextObj(end);
\nNextObj(end) = nullptr;
\n_size -= n;
\n}<\/p>\n
void* Pop()
\n{
\nassert(_freeList);<\/p>\n
\/\/\u5934\u5220
\nvoid* obj = _freeList;
\n_freeList = NextObj(obj);
\nreturn obj;<\/p>\n
–_size;
\n}<\/p>\n
bool Empty()
\n{
\nreturn _freeList == nullptr;
\n}<\/p>\n
size_t& MaxSize()
\n{
\nreturn _maxSize;
\n}<\/p>\n
size_t Size()
\n{
\nreturn _size;
\n}<\/p>\n
private:
\nvoid* _freeList=nullptr;
\nsize_t _maxSize = 1;
\nsize_t _size = 0;
\n};<\/p>\n
\/\/\u8ba1\u7b97\u5bf9\u8c61\u5927\u5c0f\u7684\u5bf9\u9f50\u6620\u5c04\u89c4\u5219
\nclass SizeClass
\n{
\npublic:
\n\/\/ \u6574\u4f53\u63a7\u5236\u5728\u6700\u591a10%\u5de6\u53f3\u7684\u5185\u788e\u7247\u6d6a\u8d39
\n \/\/ [1,128] 8byte\u5bf9\u9f50freelist[0,16) \/\/\u6700\u5f00\u59cb\u6700\u5c11\u5c31\u662f8\u5b57\u8282\u5bf9\u9f50，\u56e0\u4e3a\u6307\u9488\u662f4\u6216\u80058\u5b57\u8282，\u8981\u53d68\u5b57\u8282\u7b97，\u8fd9\u6837\u80fd\u517c\u5bb94\u5b57\u8282\u3002
\n \/\/ [128+1,1024] 16byte\u5bf9\u9f50freelist[16,72)
\n \/\/ [1024+1,8*1024] 128byte\u5bf9\u9f50freelist[72,128)
\n \/\/ [8*1024+1,64*1024] 1024byte\u5bf9\u9f50freelist[128,184)
\n \/\/ [64*1024+1,256*1024] 8*1024byte\u5bf9\u9f50 freelist[184,208)<\/p>\n
\/\/size_t _RoundUp(size_t size, size_t alignNum)
\n\/\/{
\n\/\/size_t alignSize;
\n\/\/if (size % alignNum != 0)\/\/\u5982\u679c\u4e0d\u80fd\u6574\u9664
\n\/\/{
\n\/\/alignSize = (size \/ alignNum + 1) * alignNum;\/\/\u5411\u4e0a\u5bf9\u9f50，\u5982：（5\/8+1）*8=8，\u5373\u53ef\u628a5\u5bf9\u9f50\u52308\u3002
\n\/\/}
\n\/\/else
\n\/\/{
\n\/\/alignSize = size;
\n\/\/}
\n\/\/return alignSize;
\n\/\/}<\/p>\n
static inline size_t _RoundUp(size_t bytes, size_t alignNum)
\n{
\nreturn (((bytes)+alignNum – 1) & ~(alignNum – 1));
\n}<\/p>\n
\/\/\u641e\u6210\u9759\u6001\u7684，\u5c31\u53ef\u4ee5\u4e0d\u7528\u5bf9\u8c61\u53bb\u8c03，\u91cc\u9762\u4e5f\u6ca1\u6709\u4ec0\u4e48\u6210\u5458
\nstatic inline size_t RoundUp(size_t size)\/\/\u628asize\u5411\u4e0a\u5bf9\u9f50
\n{
\nif (size <= 128)
\n{
\nreturn _RoundUp(size, 8);
\n}
\nelse if (size <= 1024)
\n{
\nreturn _RoundUp(size, 16);
\n}
\nelse if (size <=8* 1024)
\n{
\nreturn _RoundUp(size, 128);
\n}
\nelse if (size <= 64*1024)
\n{
\nreturn _RoundUp(size, 1024);
\n}
\nelse if (size <= 256*1024)
\n{
\nreturn _RoundUp(size, 8 * 1024);
\n}
\nelse
\n{
\nreturn _RoundUp(size, 1 << PAGE_SHIFT);
\n}
\n}<\/p>\n
\/\/size_t _Index(size_t bytes,size_t alignNum) alignNum\u6307\u5bf9\u9f50\u6570
\n\/\/{
\n\/\/if (bytes%alignNum==0)
\n\/\/{
\n\/\/return bytes \/ alignNum – 1;
\n\/\/}
\n\/\/else
\n\/\/{
\n\/\/return bytes \/ alignNum;
\n\/\/}
\n\/\/}<\/p>\n
static inline size_t _Index(size_t bytes, size_t align_shift) \/\/align_shift\u63072\u7684\u51e0\u6b21\u65b9，align_shift==3\u65f6，\u5de6\u79fb3\u4f4d\u5c31\u662f\u4e58\u4ee58，\u53732\u76843\u6b21\u65b9\u3002
\n{
\nreturn ((bytes + (1 << align_shift) – 1) >> align_shift) – 1;
\n}<\/p>\n
\/\/ \u8ba1\u7b97\u6620\u5c04\u5230\u54ea\u4e00\u4e2a\u81ea\u7531\u94fe\u8868\u6876
\nstatic inline size_t Index(size_t bytes)
\n{
\nassert(bytes <= MAX_BYTES);
\n\/\/ \u6bcf\u4e2a\u533a\u95f4\u6709\u591a\u5c11\u4e2a\u94fe
\nstatic int group_array[4] = { 16, 56, 56, 56 };
\nif (bytes <= 128) {
\nreturn _Index(bytes, 3);
\n}
\nelse if (bytes <= 1024) {
\nreturn _Index(bytes – 128, 4) + group_array[0];\/\/\u8bb0\u5f97\u52a0\u4e0a\u524d\u9762\u7684\u6876\u7684\u6570\u91cf
\n}
\nelse if (bytes <= 8 * 1024) {
\nreturn _Index(bytes – 1024, 7) + group_array[1] + group_array[0];
\n}
\nelse if (bytes <= 64 * 1024) {
\nreturn _Index(bytes – 8 * 1024, 10) + group_array[2] + group_array[1]
\n+ group_array[0];
\n}
\nelse if (bytes <= 256 * 1024) {
\nreturn _Index(bytes – 64 * 1024, 13) + group_array[3] +
\ngroup_array[2] + group_array[1] + group_array[0];
\n}
\nelse {
\nassert(false);
\n}
\nreturn -1;
\n}
\n\/\/ \u4e00\u6b21thread cache\u4ece\u4e2d\u5fc3\u7f13\u5b58\u83b7\u53d6\u591a\u5c11\u4e2a
\nstatic size_t NumMoveSize(size_t size) \/\/\u6279\u91cf\u8981\u591a\u4e2a，\u8fd9\u6837\u591a\u4f59\u7684，\u4e0b\u6b21\u5c31\u53ef\u4ee5\u76f4\u63a5\u5728thread cache\u4e2d\u62ff
\n{
\nassert(size > 0);<\/p>\n
\/\/ [2, 512]，\u4e00\u6b21\u6279\u91cf\u79fb\u52a8\u591a\u5c11\u4e2a\u5bf9\u8c61\u7684(\u6162\u542f\u52a8)\u4e0a\u9650\u503c
\n\/\/ \u5c0f\u5bf9\u8c61\u4e00\u6b21\u6279\u91cf\u4e0a\u9650\u9ad8
\n\/\/ \u5927\u5bf9\u8c61\u4e00\u6b21\u6279\u91cf\u4e0a\u9650\u4f4e
\nsize_t num = MAX_BYTES \/ size;
\nif (num < 2)
\nnum = 2;
\nif (num > 512)
\nnum = 512;
\nreturn num;
\n}<\/p>\n
\/\/ \u8ba1\u7b97\u4e00\u6b21\u5411\u7cfb\u7edf\u83b7\u53d6\u51e0\u4e2a\u9875
\n \/\/ \u5355\u4e2a\u5bf9\u8c61 8byte
\n \/\/ …
\n \/\/ \u5355\u4e2a\u5bf9\u8c61 256KB
\nstatic size_t NumMovePage(size_t size)
\n{
\nsize_t num = NumMoveSize(size);
\nsize_t npage = num * size;\/\/\u7b97\u51fa\u8981\u591a\u5c11\u4e2a\u5b57\u8282
\nnpage >>= PAGE_SHIFT;\/\/\u603b\u5b57\u8282\u6570\u9664\u4ee5\u4e00\u9875\u7684\u5b57\u8282\u6570，\u5f97\u51fa\u9700\u8981\u51e0\u9875\u3002
\nif (npage == 0)\/\/，\u4e0d\u8db3\u4e00\u9875\u7684，\u6700\u5c11\u4e5f\u9700\u8981\u4e00\u9875
\nnpage = 1;
\nreturn npage;
\n}<\/p>\n
};<\/p>\n
\/\/\u7ba1\u7406\u591a\u4e2a\u8fde\u7eed\u9875\u5927\u5757\u5185\u5b58\u8de8\u5ea6\u7ed3\u6784
\nstruct Span
\n{
\nPAGE_ID _pageId=0;\/\/\u5927\u5757\u5185\u5b58\u8d77\u59cb\u9875\u7684\u9875\u53f7
\nsize_t _n=0;\/\/\u9875\u7684\u6570\u91cf<\/p>\n
Span* _next=nullptr;\/\/\u53cc\u5411\u94fe\u8868\u7684\u7ed3\u6784
\nSpan* _prev=nullptr;<\/p>\n
size_t _objSize = 0;\/\/\u5207\u597d\u7684\u5c0f\u5bf9\u8c61\u7684\u5927\u5c0f
\nsize_t _useCount=0;\/\/\u5207\u597d\u7684\u5c0f\u5757\u5185\u5b58，\u88ab\u5206\u914d\u7ed9thread cache\u7684\u8ba1\u6570
\nvoid* _freeList=nullptr;\/\/\u5207\u597d\u7684\u5c0f\u5757\u5185\u5b58\u7684\u81ea\u7531\u94fe\u8868<\/p>\n
bool _isUse=false;\/\/\u662f\u5426\u5728\u88ab\u4f7f\u7528
\n};<\/p>\n
\/\/\u5e26\u5934\u53cc\u5411\u5faa\u73af\u94fe\u8868
\nclass SpanList
\n{
\npublic:
\nSpanList()
\n{
\n_head = new Span;
\n_head->_next = _head;
\n_head->_prev = _head;
\n}<\/p>\n
Span* Begin()
\n{
\nreturn _head->_next;
\n}<\/p>\n
Span* End()
\n{
\nreturn _head;
\n}<\/p>\n
bool Empty()
\n{
\nreturn _head->_next = _head;
\n}<\/p>\n
void PushFront(Span* span)
\n{
\nInsert(Begin(), span);
\n}<\/p>\n
Span* PopFront()
\n{
\nSpan* front = _head->_next;
\nErase(front);
\nreturn front;
\n}<\/p>\n
void Insert(Span* pos, Span* newSpan)
\n{
\nassert(pos);
\nassert(newSpan);<\/p>\n
Span* prev = pos->_prev;
\n\/\/prev newspan pos
\nprev->_next = newSpan;
\nnewSpan->_prev = prev;
\nnewSpan->_next = pos;
\npos->_prev = newSpan;
\n} <\/p>\n
void Erase(Span* pos)
\n{
\nassert(pos);
\nassert(pos != _head);<\/p>\n
Span* prev = pos->_prev;
\nSpan* next = pos->_next;<\/p>\n
prev->_next = next;
\nnext->_prev = prev;
\n}<\/p>\n
private:
\nSpan* _head;
\npublic:
\nstd::mutex _mtx;\/\/\u6876\u9501
\n}; <\/p>\n
#pragma once<\/p>\n
#include"Common.h"
\n#include"ThreadCache.h"
\n#include"PageCache.h"
\n#include"ObjectPool.h"<\/p>\n
\/\/\u641e\u6210\u9759\u6001\u7684，\u4fdd\u6301\u5728\u5f53\u524d\u6587\u4ef6\u53ef\u89c1\u3002 \u5982\u679c\u5168\u5c40\u7684\u4e0d\u7ed9\u9759\u6001\u7684\u8bdd，\u5728\u591a\u4e2a\u6587\u4ef6\u91cc\u9762，\u94fe\u63a5\u5c5e\u6027\u4f1a\u51b2\u7a81\u3002
\nstatic void* ConcurrentAlloc(size_t size)
\n{<\/p>\n
if (size>MAX_BYTES)
\n{
\nsize_t alignSize = SizeClass::RoundUp(size);
\nsize_t kpage = alignSize >> PAGE_SHIFT;<\/p>\n
PageCache::GetInstance()->_pageMtx.lock();
\nSpan* span = PageCache::GetInstance()->NewSpan(kpage);
\nspan->_objSize = size;
\nPageCache::GetInstance()->_pageMtx.unlock();<\/p>\n
void* ptr = (void*)(span->_pageId << PAGE_SHIFT);
\nreturn ptr;
\n}
\nelse
\n{
\n\/\/\u901a\u8fc7TLS,\u6bcf\u4e2a\u7ebf\u7a0b\u65e0\u9501\u7684\u83b7\u53d6\u81ea\u5df1\u4e13\u5c5e\u7684ThreadCache\u5bf9\u8c61
\nif (pTLSThreadCache == nullptr)
\n{
\nstatic ObjectPool<ThreadCache> tcPool;
\n\/\/pTLSThreadCache = new ThreadCache;
\npTLSThreadCache = tcPool.New();
\n}<\/p>\n
\/\/cout << std::this_thread::get_id() << ":" << pTLSThreadCache << endl;<\/p>\n
return pTLSThreadCache->Allocate(size);
\n}
\n}<\/p>\n
static void ConcurrentFree(void* ptr)
\n{
\nSpan* span = PageCache::GetInstance()->MapObjectToSpan(ptr);
\nsize_t size = span->_objSize;<\/p>\n
if (size > MAX_BYTES)
\n{<\/p>\n
PageCache::GetInstance()->_pageMtx.lock();
\nPageCache::GetInstance()->ReleaseSpanToPageCache(span);
\nPageCache::GetInstance()->_pageMtx.unlock();
\n}
\nelse
\n{
\nassert(pTLSThreadCache);
\npTLSThreadCache->Deallocate(ptr, size);
\n}
\n} <\/p>\n
#pragma once<\/p>\n
#include"Common.h"<\/p>\n
template<class T>
\nclass ObjectPool
\n{
\npublic:<\/p>\n
T* New()
\n{
\nT* obj = nullptr;<\/p>\n
\/\/\u4f18\u5148\u628a\u8fd8\u56de\u6765\u7684\u5185\u5b58\u5757\u5bf9\u8c61，\u518d\u6b21\u91cd\u590d\u5229\u7528
\nif (_freeList)
\n{
\nvoid* next = *((void**)_freeList); \/\/next\u662f\u81ea\u7531\u94fe\u8868\u7684\u7b2c\u4e00\u4e2a\u8282\u70b9\u7684\u5934\u56db\/\u516b\u4e2a\u5b57\u8282，\u5b83\u5b58\u653e\u4e0b\u4e00\u4e2a\u8282\u70b9\u7684\u5730\u5740
\nobj = (T*)_freeList;\/\/obj\u5c31\u662f\u7b2c\u4e00\u5757\u5185\u5b58\u5757
\n_freeList = next;\/\/\u518d\u8ba9next\u53d8\u6210\u7b2c\u4e00\u4e2a\u8282\u70b9
\n}
\nelse
\n{
\nif (_remainBytes < sizeof(T))\/\/\u5982\u679c\u5269\u4f59\u5185\u5b58\u5c0f\u4e8e\u6240\u9700\u5185\u5b58，\u5c31\u53bb\u7533\u8bf7\u5927\u5757\u7a7a\u95f4
\n{
\n_remainBytes = 128 * 1024;
\n_memory = (char*)malloc(_remainBytes);
\nif (_memory == nullptr)
\n{
\nthrow std::bad_alloc();
\n}
\n}<\/p>\n
obj = (T*)_memory;\/\/\u628a\u5927\u5757\u5185\u5b58\u5207\u6210\u5c0f\u5757，\u5206\u51fa\u53bb
\nsize_t objSize = sizeof(T) < sizeof(void*) ? sizeof(void*) : sizeof(T);\/\/\u4fdd\u8bc1\u81f3\u5c11\u80fd\u5b58\u653e\u4e0b\u4e00\u4e2a\u5bf9\u8c61\u7684\u5730\u5740
\n_memory += objSize;
\n_remainBytes -= objSize;
\n}<\/p>\n
\/\/malloc\u53ea\u5f00\u4e86\u7a7a\u95f4，\u6ca1\u6709\u521d\u59cb\u5316，\u8981\u8fdb\u884c\u521d\u59cb\u5316
\n\/\/\u5b9a\u4f4dnew，\u663e\u793a\u8c03\u7528T\u7684\u6784\u9020\u51fd\u6570\u521d\u59cb\u5316
\nnew(obj)T;<\/p>\n
return obj;
\n}<\/p>\n
void Delete(T* obj)
\n{
\n\/\/if (_freeList == nullptr)
\n\/\/{
\n\/\/_freeList = obj;
\n\/\/\/\/*(int*)obj=nullptr; \u5f3a\u8f6c\u6210int*\u7c7b\u578b，\u6b64\u65f6\u53ea\u80fd\u572832\u4f4d\u673a\u5668\u4e0a\u8dd1，\u56e0\u4e3a64\u4f4d\u673a\u5668\u4e0a，\u6307\u9488\u5927\u5c0f\u662f8\u5b57\u8282\u3002
\n\/\/*(void**)obj = nullptr; \/\/\u8fd9\u91cc\u4f7f\u7528\u4e8c\u7ea7\u6307\u9488\u5373\u53ef\u89e3\u51b3，void**\u89e3\u5f15\u7528\u540e，\u5c31\u662fvoid*，\u6b64\u65f6\u8fd8\u662f\u6307\u9488，\u572832\u4f4d\u673a\u5668\u4e0a\u5c31\u662f4\u5b57\u8282，\u572864\u4f4d\u673a\u5668\u4e0a\u5c31\u662f8\u5b57\u8282，\u53ef\u4ee5\u81ea\u52a8\u9002\u5e94
\n\/\/}
\n\/\/else
\n\/\/{
\n\/\/\/\/\u5934\u63d2
\n\/\/*(void**)obj = _freeList; \/\/\u5148\u8ba9\u5c0f\u5185\u5b58\u5757\u6307\u5411\u81ea\u7531\u94fe\u8868\u7684\u7b2c\u4e00\u4e2a\u8282\u70b9，\u56e0\u4e3afreeList\u6307\u5411\u7684\u5c31\u662f\u7b2c\u4e00\u4e2a\u8282\u70b9\u3002
\n\/\/_freeList = obj; \/\/\u63a5\u7740\u518d\u8ba9obj\u53d8\u6210\u7b2c\u4e00\u4e2a\u8282\u70b9，\u8ba9freelist\u6307\u5411boj\u3002
\n\/\/}<\/p>\n
\/\/\u663e\u793a\u8c03\u7528\u6790\u6784\u51fd\u6570\u6e05\u7406\u5bf9\u8c61
\nobj->~T();<\/p>\n
\/\/\u5934\u63d2
\n*(void**)obj = _freeList; \/\/\u5b9e\u9645\u4e0a\u4e0d\u9700\u8981\u533a\u5206\u60c5\u51b5，\u56e0\u4e3a\u7a7a\u7684\u65f6\u5019，\u76f4\u63a5\u5934\u63d2\u4e5f\u53ef\u4ee5
\n_freeList = obj; <\/p>\n
}<\/p>\n
private:
\nchar* _memory=nullptr;\/\/\u56e0\u4e3a\u4e00\u4e2achar\u662f\u4e00\u4e2a\u5b57\u8282，\u5207\u5185\u5b58\u5757\u65f6\u597d\u7528\u3002\u6307\u5411\u5927\u5757\u5185\u5b58\u7684\u6307\u9488
\nsize_t _remainBytes = 0;\/\/\u5927\u5757\u5185\u5b58\u5728\u5207\u5206\u8fc7\u7a0b\u4e2d\u5269\u4f59\u5b57\u8282\u6570
\nvoid* _freeList=nullptr;\/\/\u8fd8\u56de\u6765\u8fc7\u7a0b\u4e2d\u94fe\u63a5\u7684\u81ea\u7531\u94fe\u8868\u7684\u5934\u6307\u9488
\n};<\/p>\n
\/\/struct TreeNode
\n\/\/{
\n\/\/int _val;
\n\/\/TreeNode* _left;
\n\/\/TreeNode* _right;
\n\/\/TreeNode()
\n\/\/:_val(0)
\n\/\/, _left(nullptr)
\n\/\/, _right(nullptr)
\n\/\/{}
\n\/\/};
\n\/\/void TestObjectPool()
\n\/\/{
\n\/\/\/\/ \u7533\u8bf7\u91ca\u653e\u7684\u8f6e\u6b21
\n\/\/const size_t Rounds = 3;
\n\/\/\/\/ \u6bcf\u8f6e\u7533\u8bf7\u91ca\u653e\u591a\u5c11\u6b21
\n\/\/const size_t N = 100000;
\n\/\/std::vector<TreeNode*> v1;
\n\/\/v1.reserve(N);
\n\/\/
\n\/\/size_t begin1 = clock();
\n\/\/for (size_t j = 0; j < Rounds; ++j)
\n\/\/{
\n\/\/for (int i = 0; i < N; ++i)
\n\/\/{
\n\/\/v1.push_back(new TreeNode);
\n\/\/}
\n\/\/for (int i = 0; i < N; ++i)
\n\/\/{
\n\/\/delete v1[i];
\n\/\/}
\n\/\/v1.clear();
\n\/\/}
\n\/\/size_t end1 = clock();
\n\/\/std::vector<TreeNode*> v2;
\n\/\/v2.reserve(N);
\n\/\/ObjectPool<TreeNode> TNPool;
\n\/\/size_t begin2 = clock();
\n\/\/
\n\/\/for (size_t j = 0; j < Rounds; ++j)
\n\/\/{
\n\/\/for (int i = 0; i < N; ++i)
\n\/\/{
\n\/\/v2.push_back(TNPool.New());
\n\/\/}
\n\/\/for (int i = 0; i < N; ++i)
\n\/\/{
\n\/\/TNPool.Delete(v2[i]);
\n\/\/}
\n\/\/v2.clear();
\n\/\/}
\n\/\/size_t end2 = clock();
\n\/\/cout << "new cost time:" << end1 – begin1 << endl;
\n\/\/cout << "object pool cost time:" << end2 – begin2 << endl;
\n\/\/}<\/p>\n
#pragma once<\/p>\n
#include"Common.h"
\n#include"ObjectPool.h"
\n#include"PageMap.h"<\/p>\n
class PageCache
\n{
\npublic:
\nstatic PageCache* GetInstance()
\n{
\nreturn &_sInst;
\n}<\/p>\n
\/\/ \u83b7\u53d6\u4ece\u5bf9\u8c61\u5230span\u7684\u6620\u5c04
\nSpan* MapObjectToSpan(void* obj);<\/p>\n
\/\/ \u91ca\u653e\u7a7a\u95f2span\u56de\u5230Pagecache，\u5e76\u5408\u5e76\u76f8\u90bb\u7684span
\nvoid ReleaseSpanToPageCache(Span* span);<\/p>\n
\/\/ \u83b7\u53d6\u4e00\u4e2aK\u9875\u7684span
\nSpan* NewSpan(size_t k);<\/p>\n
std::mutex _pageMtx;<\/p>\n
private:
\nSpanList _spanLists[NPAGES];
\nObjectPool<Span> _spanPool;<\/p>\n
\/\/std::unordered_map<PAGE_ID, Span*> _idSpanMap;
\nTCMalloc_PageMap1<32 – PAGE_SHIFT> _idSpanMap;<\/p>\n
PageCache()
\n{}<\/p>\n
PageCache(const PageCache&) = delete;<\/p>\n
static PageCache _sInst;<\/p>\n
}; <\/p>\n
#pragma once<\/p>\n
#include"Common.h"<\/p>\n
\/\/ Single-level array
\ntemplate <int BITS>
\nclass TCMalloc_PageMap1 {
\nprivate:
\nstatic const int LENGTH = 1 << BITS;
\nvoid** array_;
\npublic:
\ntypedef uintptr_t Number;
\n\/\/explicit TCMalloc_PageMap1(void* (*allocator)(size_t)) {
\nexplicit TCMalloc_PageMap1() {
\n\/\/array_ = reinterpret_cast<void**>((*allocator)(sizeof(void*) << BITS));
\nsize_t size = sizeof(void*) << BITS;
\nsize_t alignSize = SizeClass::_RoundUp(size, 1 << PAGE_SHIFT);
\narray_ = (void**)SystemAlloc(alignSize>>PAGE_SHIFT);
\nmemset(array_, 0, sizeof(void*) << BITS);
\n}
\n\/\/ Return the current value for KEY. Returns NULL if not yet set,
\n\/\/ or if k is out of range.
\nvoid* get(Number k) const {
\nif ((k >> BITS) > 0) {
\nreturn NULL;
\n}
\nreturn array_[k];
\n}
\n\/\/ REQUIRES "k" is in range "[0,2^BITS-1]".
\n\/\/ REQUIRES "k" has been ensured before.
\n\/\/
\n\/\/ Sets the value 'v' for key 'k'.
\nvoid set(Number k, void* v) {
\narray_[k] = v;
\n}
\n};
\n\/\/ Two-level radix tree
\ntemplate <int BITS>
\nclass TCMalloc_PageMap2 {
\nprivate:
\n\/\/ Put 32 entries in the root and (2^BITS)\/32 entries in each leaf.
\nstatic const int ROOT_BITS = 5;
\nstatic const int ROOT_LENGTH = 1 << ROOT_BITS;
\nstatic const int LEAF_BITS = BITS – ROOT_BITS;
\nstatic const int LEAF_LENGTH = 1 << LEAF_BITS;
\n\/\/ Leaf node
\nstruct Leaf {
\nvoid* values[LEAF_LENGTH];
\n};
\nLeaf* root_[ROOT_LENGTH]; \/\/ Pointers to 32 child nodes
\nvoid* (*allocator_)(size_t); \/\/ Memory allocator
\npublic:
\ntypedef uintptr_t Number;
\n\/\/explicit TCMalloc_PageMap2(void* (*allocator)(size_t)) {
\nexplicit TCMalloc_PageMap2() {
\n\/\/allocator_ = allocator;
\nmemset(root_, 0, sizeof(root_));<\/p>\n
PreallocateMoreMemory();
\n}
\nvoid* get(Number k) const {
\nconst Number i1 = k >> LEAF_BITS;
\nconst Number i2 = k & (LEAF_LENGTH – 1);
\nif ((k >> BITS) > 0 || root_[i1] == NULL) {
\nreturn NULL;
\n}
\nreturn root_[i1]->values[i2];
\n}
\nvoid set(Number k, void* v) {
\nconst Number i1 = k >> LEAF_BITS;
\nconst Number i2 = k & (LEAF_LENGTH – 1);
\nASSERT(i1 < ROOT_LENGTH);
\nroot_[i1]->values[i2] = v;
\n}
\nbool Ensure(Number start, size_t n) {
\nfor (Number key = start; key <= start + n – 1;) {
\nconst Number i1 = key >> LEAF_BITS;
\n\/\/ Check for overflow
\nif (i1 >= ROOT_LENGTH)
\nreturn false;
\n\/\/ Make 2nd level node if necessary
\nif (root_[i1] == NULL) {
\n\/\/Leaf* leaf = reinterpret_cast<Leaf*>((*allocator_)(sizeof(Leaf)));
\n\/\/if (leaf == NULL) return false;
\nstatic ObjectPool<Leaf> leafPool;
\nLeaf* leaf = (Leaf*)leafPool.New();<\/p>\n
memset(leaf, 0, sizeof(*leaf));
\nroot_[i1] = leaf;
\n}
\n\/\/ Advance key past whatever is covered by this leaf node
\nkey = ((key >> LEAF_BITS) + 1) << LEAF_BITS;
\n}
\nreturn true;
\n}
\nvoid PreallocateMoreMemory() {
\n\/\/ Allocate enough to keep track of all possible pages
\nEnsure(0, 1 << BITS);
\n}
\n};
\n\/\/ Three-level radix tree
\ntemplate <int BITS>
\nclass TCMalloc_PageMap3 {
\nprivate:
\n\/\/ How many bits should we consume at each interior level
\nstatic const int INTERIOR_BITS = (BITS + 2) \/ 3; \/\/ Round-up
\nstatic const int INTERIOR_LENGTH = 1 << INTERIOR_BITS;
\n\/\/ How many bits should we consume at leaf level
\nstatic const int LEAF_BITS = BITS – 2 * INTERIOR_BITS;
\nstatic const int LEAF_LENGTH = 1 << LEAF_BITS;
\n\/\/ Interior node
\nstruct Node {
\nNode* ptrs[INTERIOR_LENGTH];
\n};
\n\/\/ Leaf node
\nstruct Leaf {
\nvoid* values[LEAF_LENGTH];
\n};
\nNode* root_; \/\/ Root of radix tree
\nvoid* (*allocator_)(size_t); \/\/ Memory allocator
\nNode* NewNode() {
\nNode* result = reinterpret_cast<Node*>((*allocator_)(sizeof(Node)));
\nif (result != NULL) {
\nmemset(result, 0, sizeof(*result));
\n}
\nreturn result;
\n}
\npublic:
\ntypedef uintptr_t Number;
\nexplicit TCMalloc_PageMap3(void* (*allocator)(size_t)) {
\nallocator_ = allocator;
\nroot_ = NewNode();
\n}
\nvoid* get(Number k) const {
\nconst Number i1 = k >> (LEAF_BITS + INTERIOR_BITS);
\nconst Number i2 = (k >> LEAF_BITS) & (INTERIOR_LENGTH – 1);
\nconst Number i3 = k & (LEAF_LENGTH – 1);
\nif ((k >> BITS) > 0 ||
\nroot_->ptrs[i1] == NULL || root_->ptrs[i1]->ptrs[i2] == NULL) {
\nreturn NULL;
\n}
\nreturn reinterpret_cast<Leaf*>(root_->ptrs[i1]->ptrs[i2])->values[i3];
\n}
\nvoid set(Number k, void* v) {
\nASSERT(k >> BITS == 0);
\nconst Number i1 = k >> (LEAF_BITS + INTERIOR_BITS);
\nconst Number i2 = (k >> LEAF_BITS) & (INTERIOR_LENGTH – 1);
\nconst Number i3 = k & (LEAF_LENGTH – 1);
\nreinterpret_cast<Leaf*>(root_->ptrs[i1]->ptrs[i2])->values[i3] = v;
\n}
\nbool Ensure(Number start, size_t n) {
\nfor (Number key = start; key <= start + n – 1;) {
\nconst Number i1 = key >> (LEAF_BITS + INTERIOR_BITS);
\nconst Number i2 = (key >> LEAF_BITS) & (INTERIOR_LENGTH – 1);
\n\/\/ Check for overflow
\nif (i1 >= INTERIOR_LENGTH || i2 >= INTERIOR_LENGTH)
\nreturn false;
\n\/\/ Make 2nd level node if necessary
\nif (root_->ptrs[i1] == NULL) {
\nNode* n = NewNode();
\nif (n == NULL) return false;
\nroot_->ptrs[i1] = n;
\n}
\n\/\/ Make leaf node if necessary
\nif (root_->ptrs[i1]->ptrs[i2] == NULL) {
\nLeaf* leaf = reinterpret_cast<Leaf*>((*allocator_)
\n(sizeof(Leaf)));
\nif (leaf == NULL) return false;
\nmemset(leaf, 0, sizeof(*leaf));
\nroot_->ptrs[i1]->ptrs[i2] = reinterpret_cast<Node*>(leaf);
\n}
\n\/\/ Advance key past whatever is covered by this leaf node
\nkey = ((key >> LEAF_BITS) + 1) << LEAF_BITS;
\n}
\nreturn true;
\n}
\nvoid PreallocateMoreMemory() {
\n}
\n}; <\/p>\n
\u4f7f\u7528tcmalloc\u6e90\u7801\u4e2d\u5b9e\u73b0\u57fa\u6570\u6811\u8fdb\u884c\u4f18\u5316<\/p>\n
#pragma once<\/p>\n
#include"Common.h"<\/p>\n
class ThreadCache
\n{
\npublic:
\n\/\/\u7533\u8bf7\u548c\u91ca\u653e\u5185\u5b58\u5bf9\u8c61
\nvoid* Allocate(size_t size);
\nvoid Deallocate(void* ptr, size_t size); <\/p>\n
\/\/ \u4ece\u4e2d\u5fc3\u7f13\u5b58\u83b7\u53d6\u5bf9\u8c61
\nvoid* FetchFromCentralCache(size_t index, size_t size);<\/p>\n
\/\/ \u91ca\u653e\u5bf9\u8c61\u65f6，\u94fe\u8868\u8fc7\u957f\u65f6，\u56de\u6536\u5185\u5b58\u56de\u5230\u4e2d\u5fc3\u7f13\u5b58
\nvoid ListTooLong(FreeList& list, size_t size);
\nprivate:
\nFreeList _freeLists[NFREELIST];
\n};<\/p>\n
\/\/TLS thread local storage \/\/\u6bcf\u4e2a\u7ebf\u7a0b\u8d77\u6765\u540e，\u5c31\u4f1a\u8c03\u7528\u7533\u8bf7\u5185\u5b58\u7684\u63a5\u53e3\u83b7\u5f97thread cache,\u800c\u4e0d\u662f\u76f4\u63a5\u5c31\u6709\u5404\u81ea\u7684thread cache
\nstatic _declspec(thread) ThreadCache* pTLSThreadCache = nullptr; \/\/\u8ba9\u53d8\u91cf\u90fd\u53ea\u5728\u5b83\u6240\u5728\u7684\u7ebf\u7a0b\u53ef\u5168\u5c40\u8bbf\u95ee，\u4f46\u4e0d\u80fd\u88ab\u5176\u4ed6\u7ebf\u7a0b\u8bbf\u95ee\u5230\u3002TLS(\u7ebf\u7a0b\u5c40\u90e8\u5b58\u50a8) <\/p>\n
#include"ConcurrentAlloc.h"<\/p>\n
\/\/ntimes \u4e00\u8f6e\u7533\u8bf7\u548c\u91ca\u653e\u5185\u5b58\u7684\u6b21\u6570
\n\/\/rounds \u8f6e\u6b21
\nvoid BenchmarkMalloc(size_t ntimes, size_t nworks, size_t rounds)
\n{
\nstd::vector<std::thread> vthread(nworks);
\nstd::atomic<size_t> malloc_costtime = 0;
\nstd::atomic<size_t> free_costtime = 0;
\nfor (size_t k = 0; k < nworks; ++k)
\n{
\nvthread[k] = std::thread([&, k]() {
\nstd::vector<void*> v;
\nv.reserve(ntimes);
\nfor (size_t j = 0; j < rounds; ++j)
\n{
\nsize_t begin1 = clock();
\nfor (size_t i = 0; i < ntimes; i++)
\n{
\nv.push_back(malloc(16));
\n\/\/v.push_back(malloc((16 + i) % 8192 + 1));
\n}
\nsize_t end1 = clock();
\nsize_t begin2 = clock();
\nfor (size_t i = 0; i < ntimes; i++)
\n{
\nfree(v[i]);
\n}
\nsize_t end2 = clock();
\nv.clear();
\nmalloc_costtime += (end1 – begin1);
\nfree_costtime += (end2 – begin2);
\n}
\n});
\n}
\nfor (auto& t : vthread)
\n{
\nt.join();
\n}
\nprintf("%u\u4e2a\u7ebf\u7a0b\u5e76\u53d1\u6267\u884c%u\u8f6e\u6b21，\u6bcf\u8f6e\u6b21malloc %u\u6b21: \u82b1\u8d39：%u ms\\\\n",
\nnworks, rounds, ntimes, malloc_costtime);
\nprintf("%u\u4e2a\u7ebf\u7a0b\u5e76\u53d1\u6267\u884c%u\u8f6e\u6b21，\u6bcf\u8f6e\u6b21free %u\u6b21: \u82b1\u8d39：%u ms\\\\n",
\nnworks, rounds, ntimes, free_costtime);
\nprintf("%u\u4e2a\u7ebf\u7a0b\u5e76\u53d1malloc&free %u\u6b21，\u603b\u8ba1\u82b1\u8d39：%u ms\\\\n",
\nnworks, nworks * rounds * ntimes, malloc_costtime + free_costtime);
\n}
\n\/\/ \u5355\u8f6e\u6b21\u7533\u8bf7\u91ca\u653e\u6b21\u6570 \u7ebf\u7a0b\u6570 \u8f6e\u6b21
\nvoid BenchmarkConcurrentMalloc(size_t ntimes, size_t nworks, size_t rounds)
\n{
\nstd::vector<std::thread> vthread(nworks);
\nstd::atomic<size_t> malloc_costtime = 0;
\nstd::atomic<size_t> free_costtime = 0;
\nfor (size_t k = 0; k < nworks; ++k)
\n{
\nvthread[k] = std::thread([&]() {
\nstd::vector<void*> v;
\nv.reserve(ntimes);
\nfor (size_t j = 0; j < rounds; ++j)
\n{
\nsize_t begin1 = clock();
\nfor (size_t i = 0; i < ntimes; i++)
\n{
\nv.push_back(ConcurrentAlloc(16));
\n\/\/v.push_back(ConcurrentAlloc((16 + i) % 8192 + 1));
\n}
\nsize_t end1 = clock();
\nsize_t begin2 = clock();
\nfor (size_t i = 0; i < ntimes; i++)
\n{
\nConcurrentFree(v[i]);
\n}
\nsize_t end2 = clock();
\nv.clear();
\nmalloc_costtime += (end1 – begin1);
\nfree_costtime += (end2 – begin2);
\n}
\n});
\n}
\nfor (auto& t : vthread)
\n{
\nt.join();
\n}
\nprintf("%u\u4e2a\u7ebf\u7a0b\u5e76\u53d1\u6267\u884c%u\u8f6e\u6b21，\u6bcf\u8f6e\u6b21concurrent alloc %u\u6b21: \u82b1\u8d39：%u ms\\\\n",
\nnworks, rounds, ntimes, malloc_costtime);
\nprintf("%u\u4e2a\u7ebf\u7a0b\u5e76\u53d1\u6267\u884c%u\u8f6e\u6b21，\u6bcf\u8f6e\u6b21concurrent dealloc %u\u6b21: \u82b1\u8d39：%u ms\\\\n",
\nnworks, rounds, ntimes, free_costtime);
\nprintf("%u\u4e2a\u7ebf\u7a0b\u5e76\u53d1concurrent alloc&dealloc %u\u6b21，\u603b\u8ba1\u82b1\u8d39：%u ms\\\\n",
\nnworks, nworks * rounds * ntimes, malloc_costtime + free_costtime);
\n}<\/p>\n
int main()
\n{
\nsize_t n = 10000;
\ncout << "==========================================================" <<
\nendl;
\nBenchmarkConcurrentMalloc(n, 4, 10);
\ncout << endl << endl;
\nBenchmarkMalloc(n, 4, 10);
\ncout << "==========================================================" <<
\nendl;
\nreturn 0;
\n} <\/p>\n
\u591a\u7ebf\u7a0b\u5e76\u53d1\u73af\u5883\u4e0b，\u5bf9\u6bd4malloc\u548cConcurrentAlloc\u7533\u8bf7\u548c\u91ca\u653e\u5185\u5b58\u6548\u7387\u5bf9\u6bd4<\/p>\n
#include"CentralCache.h"
\n#include"PageCache.h"<\/p>\n
CentralCache CentralCache::_sInst;<\/p>\n
\/\/ \u83b7\u53d6\u4e00\u4e2a\u975e\u7a7a\u7684span
\nSpan* CentralCache::GetOneSpan(SpanList& list, size_t size)
\n{
\n\/\/\u67e5\u770b\u5f53\u524d\u7684spanlist\u4e2d\u662f\u5426\u8fd8\u6709\u672a\u5206\u914d\u5bf9\u8c61\u7684span
\nSpan* it = list.Begin();
\nwhile (it != list.End())
\n{
\nif (it->_freeList != nullptr)
\n{
\nreturn it;
\n}
\nelse
\n{
\nit = it->_next;
\n}
\n}<\/p>\n
\/\/\u5148\u628acentral cache\u7684\u6876\u9501\u89e3\u6389，\u8fd9\u6837\u5982\u679c\u5176\u4ed6\u7ebf\u7a0b\u91ca\u653e\u5185\u5b58\u5bf9\u8c61\u56de\u6765，\u4e0d\u4f1a\u963b\u585e
\nlist._mtx.unlock();<\/p>\n
\/\/\u8d70\u5230\u8fd9\u91cc\u8bf4\u660e\u6ca1\u6709\u7a7a\u95f2\u7684span\u4e86，\u53ea\u80fd\u627epage cache\u8981
\nPageCache::GetInstance()->_pageMtx.lock();
\nSpan* span = PageCache::GetInstance()->NewSpan(SizeClass::NumMovePage(size));
\nspan->_isUse = true;
\nspan->_objSize = size;
\nPageCache::GetInstance()->_pageMtx.unlock();<\/p>\n
\/\/\u5bf9\u83b7\u53d6span\u8fdb\u884c\u5207\u5206，\u4e0d\u9700\u8981\u52a0\u9501，\u56e0\u4e3a\u8fd9\u65f6\u5019\u5176\u4ed6\u7ebf\u7a0b\u8bbf\u95ee\u4e0d\u5230\u8fd9\u4e2aspan<\/p>\n
\/\/\u8ba1\u7b97span\u7684\u5927\u5757\u5185\u5b58\u7684\u8d77\u59cb\u5730\u5740\u548c\u5927\u5757\u5185\u5b58\u7684\u5927\u5c0f（\u5b57\u8282\u6570）
\nchar* start = (char*)(span->_pageId << PAGE_SHIFT);
\nsize_t bytes = span->_n << PAGE_SHIFT;
\nchar* end = start + bytes;<\/p>\n
\/\/\u628a\u5927\u5757\u5185\u5b58\u5207\u6210\u81ea\u7531\u94fe\u8868\u94fe\u63a5\u8d77\u6765
\n\/\/1.\u5148\u5207\u4e00\u5757\u4e0b\u6765\u53bb\u505a\u5934，\u65b9\u4fbf\u5c3e\u63d2
\nspan->_freeList = start;
\nstart += size;
\nvoid* tail = span->_freeList;<\/p>\n
int i = 1;
\nwhile (start < end)
\n{
\n++i;
\nNextObj(tail) = start;
\ntail = NextObj(tail);\/\/ \u6216\u8005tail=start
\nstart += size;
\n}<\/p>\n
NextObj(tail) = nullptr; <\/p>\n
\/\/\u5207\u597dspan\u4ee5\u540e，\u9700\u8981\u628aspan\u6302\u5230\u6876\u91cc\u53bb\u7684\u65f6\u5019，\u518d\u52a0\u9501
\nlist._mtx.lock();
\nlist.PushFront(span);<\/p>\n
return span;
\n}<\/p>\n
\/\/ \u4ece\u4e2d\u5fc3\u7f13\u5b58\u83b7\u53d6\u4e00\u5b9a\u6570\u91cf\u7684\u5bf9\u8c61\u7ed9thread cache
\nsize_t CentralCache::FetchRangeObj(void*& start, void*& end, size_t batchNum, size_t size)
\n{
\nsize_t index = SizeClass::Index(size);\/\/\u627e\u51fa\u662f\u54ea\u4e2a\u6876\u7684
\n_spanLists[index]._mtx.lock(); <\/p>\n
Span* span = GetOneSpan(_spanLists[index], size);
\nassert(span);
\nassert(span->_freeList);<\/p>\n
\/\/\u4ecespan\u4e2d\u83b7\u53d6batchNum\u4e2a\u5bf9\u8c61
\n\/\/\u5982\u679c\u4e0d\u591fbatchNum\u4e2a，\u6709\u591a\u5c11\u62ff\u591a\u5c11
\nstart = span->_freeList;
\nend = start;
\nsize_t i = 0;
\nsize_t actualNum = 1;\/\/\u56e0\u4e3a\u662f\u5c11\u8d70\u4e00\u6b65\u7684，\u6240\u4ee5\u8d77\u59cb\u5c31\u5df2\u7ecf\u6709\u4e00\u4e2a\u4e86
\nwhile(i < batchNum – 1 && NextObj(end)!=nullptr)
\n{
\nend = NextObj(end);
\ni++;
\n++actualNum;
\n}
\nspan->_freeList = NextObj(end);
\nNextObj(end) = nullptr;
\nspan->_useCount += actualNum;<\/p>\n
_spanLists[index]._mtx.unlock();
\nreturn actualNum;
\n}<\/p>\n
void CentralCache::ReleaseListToSpans(void* start, size_t size)
\n{
\nsize_t index = SizeClass::Index(size);\/\/\u6839\u636esize\u7b97\u51fa\u662f\u54ea\u4e2a\u6876\u7684
\n_spanLists[index]._mtx.lock();<\/p>\n
while (start)
\n{
\nvoid* next = NextObj(start);<\/p>\n
Span* span = PageCache::GetInstance()->MapObjectToSpan(start);\/\/\u627e\u5230\u5bf9\u5e94\u7684span
\nNextObj(start) = span->_freeList;
\nspan->_freeList = start;
\nspan->_useCount–;<\/p>\n
\/\/==0，\u8bf4\u660espan\u5207\u5206\u51fa\u53bb\u7684\u6240\u6709\u5c0f\u5757\u5185\u5b58\u90fd\u56de\u6765\u4e86
\n\/\/\u8fd9\u4e2aspan\u5c31\u53ef\u4ee5\u518d\u56de\u6536\u7ed9page cache，pagecache\u5c31\u53ef\u4ee5\u518d\u5c1d\u8bd5\u53bb\u505a\u524d\u540e\u9875\u7684\u5408\u5e76
\nif (span->_useCount == 0)
\n{
\n_spanLists[index].Erase(span);\/\/\u628a\u6ee1\u4e86\u7684span\u4ece\u94fe\u8868\u91cc\u62ff\u51fa\u6765
\nspan->_freeList = nullptr;\/\/\u867d\u7136\u8fd9\u4e2aspan\u91cc\u7684\u5c0f\u5757\u5185\u5b58\u5df2\u7ecf\u65e0\u5e8f，\u4f46\u662f\u6211\u4eec\u5df2\u7ecf\u77e5\u9053\u8d77\u59cb\u548c\u7ec8\u6b62\u5730\u5740，\u6240\u4ee5\u53ef\u4ee5\u7f6e\u7a7a
\nspan->_next = nullptr;
\nspan->_prev = nullptr;<\/p>\n
\/\/\u91ca\u653espan\u7ed9page cache\u65f6，\u4f7f\u7528page cache\u7684\u9501\u5373\u53ef
\n\/\/\u8fd9\u65f6\u8981\u628a\u6876\u9501\u89e3\u6389
\n_spanLists[index]._mtx.unlock();<\/p>\n
PageCache::GetInstance()->_pageMtx.lock();
\nPageCache::GetInstance()->ReleaseSpanToPageCache(span);
\nPageCache::GetInstance()->_pageMtx.unlock(); <\/p>\n
_spanLists[index]._mtx.lock();
\n}<\/p>\n
start = next;
\n}<\/p>\n
_spanLists[index]._mtx.unlock();<\/p>\n
} <\/p>\n
#include"PageCache.h"<\/p>\n
PageCache PageCache::_sInst;<\/p>\n
\/\/ \u83b7\u53d6\u4e00\u4e2aK\u9875\u7684span
\nSpan* PageCache::NewSpan(size_t k)
\n{
\nassert(k > 0);<\/p>\n
\/\/\u5927\u4e8e128 page\u7684\u76f4\u63a5\u5411\u5806\u7533\u8bf7
\nif (k > NPAGES – 1)
\n{
\nvoid* ptr = SystemAlloc(k);
\n\/\/Span* span = new Span;
\nSpan* span = _spanPool.New();
\nspan->_pageId = (PAGE_ID)ptr >> PAGE_SHIFT;
\nspan->_n = k;<\/p>\n
\/\/_idSpanMap[span->_pageId] = span;
\n_idSpanMap.set(span->_pageId, span);<\/p>\n
return span;
\n}<\/p>\n
\/\/\u5148\u68c0\u67e5\u7b2ck\u4e2a\u6876\u91cc\u9762\u6709\u6ca1\u6709span
\nif (!_spanLists[k].Empty())
\n{
\nSpan* kSpan = _spanLists[k].PopFront();
\n\/\/\u5efa\u7acbid\u548cspan\u7684\u6620\u5c04，\u65b9\u4fbfcentral cache\u56de\u6536\u5c0f\u5757\u5185\u5b58\u65f6，\u67e5\u627e\u5bf9\u5e94\u7684span
\nfor (PAGE_ID i = 0; i < kSpan->_n; ++i)
\n{
\n\/\/_idSpanMap[kSpan->_pageId + i] = kSpan;
\n_idSpanMap.set(kSpan->_pageId + i,kSpan);
\n}
\nreturn kSpan;
\n}<\/p>\n
\/\/\u68c0\u67e5\u4e00\u4e0b\u540e\u9762\u7684\u6876\u91cc\u6709\u6ca1\u6709span，\u5982\u679c\u6709\u53ef\u4ee5\u628a\u5b83\u8fdb\u884c\u5207\u5206
\nfor (size_t i = k + 1; i < NPAGES; i++)
\n{
\nif (!_spanLists[i].Empty())
\n{
\nSpan* nSpan = _spanLists[i].PopFront();
\n\/\/Span* kSpan = new Span;
\nSpan* kSpan = _spanPool.New();<\/p>\n
\/\/\u5728nSpan\u7684\u5934\u90e8\u5207\u4e00\u4e2ak\u9875\u4e0b\u6765
\n\/\/k\u9875\u7684span\u8fd4\u56de
\n\/\/nSpan\u518d\u6302\u5230\u5bf9\u5e94\u6620\u5c04\u7684\u4f4d\u7f6e
\nkSpan->_pageId = nSpan->_pageId; \/\/\u5207\u51fa\u6765\u7684\u9875\u53f7\u7ed9kSpan
\nkSpan->_n = k; \/\/\u5207\u51fa\u6765\u7684\u9875\u6570\u662fk<\/p>\n
nSpan->_pageId += k;\/\/nSpan\u7684\u8d77\u59cb\u9875\u53f7\u589e\u52a0
\nnSpan->_n -= k;\/\/nSpan\u7684\u9875\u6570\u51cf\u5c11k<\/p>\n
_spanLists[nSpan->_n].PushFront(nSpan);\/\/\u628anSpan\u5934\u63d2\u5230\u5bf9\u5e94\u7684\u6876\u4e0a<\/p>\n
\/\/\u8fd9\u91cc\u53ea\u9700\u8981\u9996\u5c3e\u6620\u5c04，\u56e0\u4e3a\u5408\u5e76\u7684\u65f6\u5019，\u53ea\u9700\u8981\u627e\u5230\u9996\u6216\u5c3e\u7684\u5373\u53ef
\n\/\/\u5b58\u50a8nSpan\u7684\u9996\u5c3e\u9875\u53f7\u8ddfnSpan\u6620\u5c04，\u65b9\u4fbfpage cache\u56de\u6536\u5185\u5b58\u65f6\u8fdb\u884c\u5408\u5e76\u67e5\u627e
\n\/\/_idSpanMap[nSpan->_pageId] = nSpan;
\n\/\/_idSpanMap[nSpan->_pageId+nSpan->_n-1] = nSpan;
\n_idSpanMap.set(nSpan->_pageId, nSpan);
\n_idSpanMap.set(nSpan->_pageId + nSpan->_n – 1, nSpan);<\/p>\n
\/\/\u8fd9\u91cc\u662f\u56e0\u4e3akspan\u4f1a\u88ab\u5207\u6210\u4e00\u5c0f\u5757\u4e00\u5c0f\u5757\u7684，\u6240\u4ee5\u9700\u8981\u6bcf\u4e00\u4e2a\u5c0f\u5757\u5185\u5b58\u90fd\u6620\u5c04
\n\/\/\u5efa\u7acbid\u548cspan\u7684\u6620\u5c04，\u65b9\u4fbfcentral cache\u56de\u6536\u5c0f\u5757\u5185\u5b58\u65f6，\u67e5\u627e\u5bf9\u5e94\u7684span
\nfor (PAGE_ID i = 0; i < kSpan->_n;++i)
\n{
\n\/\/_idSpanMap[kSpan->_pageId + i] = kSpan;
\n_idSpanMap.set(kSpan->_pageId + i, kSpan);
\n}<\/p>\n
return kSpan;
\n}
\n}<\/p>\n
\/\/\u8d70\u5230\u8fd9\u4e2a\u4f4d\u7f6e\u5c31\u8bf4\u660e\u540e\u9762\u6ca1\u6709\u5927\u9875\u7684span\u4e86
\n\/\/\u8fd9\u65f6\u5c31\u53bb\u627e\u5806\u8981\u4e00\u4e2a128\u9875\u7684span
\n\/\/Span* bigSpan = new Span;
\nSpan* bigSpan = _spanPool.New();
\nvoid* ptr = SystemAlloc(NPAGES – 1);
\nbigSpan->_pageId = (PAGE_ID)ptr >> PAGE_SHIFT;
\nbigSpan->_n = NPAGES – 1;<\/p>\n
_spanLists[bigSpan->_n].PushFront(bigSpan);<\/p>\n
return NewSpan(k);<\/p>\n
}<\/p>\n
Span* PageCache::MapObjectToSpan(void* obj)
\n{
\nPAGE_ID id = ((PAGE_ID)obj >> PAGE_SHIFT);<\/p>\n
\/\/std::unique_lock<std::mutex> lock(_pageMtx);
\n\/\/
\n\/\/auto ret = _idSpanMap.find(id);
\n\/\/if (ret != _idSpanMap.end())
\n\/\/{
\n\/\/return ret->second;
\n\/\/}
\n\/\/else
\n\/\/{
\n\/\/assert(false);
\n\/\/return nullptr;
\n\/\/}<\/p>\n
auto ret = (Span*)_idSpanMap.get(id);
\nassert(ret != nullptr);
\nreturn ret;
\n}<\/p>\n
void PageCache::ReleaseSpanToPageCache(Span* span)
\n{
\n\/\/\u5927\u4e8e128 page\u7684\u76f4\u63a5\u8fd8\u7ed9\u5806
\nif (span->_n > NPAGES – 1)
\n{
\nvoid* ptr = (void*)(span->_pageId << PAGE_SHIFT);
\nSystemFree(ptr);
\n\/\/delete span;
\n_spanPool.Delete(span);<\/p>\n
return;
\n}<\/p>\n
\/\/\u5bf9span\u524d\u540e\u7684\u9875，\u5c1d\u8bd5\u8fdb\u884c\u5408\u5e76，\u7f13\u89e3\u5185\u5b58\u788e\u7247\u95ee\u9898
\nwhile (1)
\n{
\nPAGE_ID prevId = span->_pageId – 1;
\n\/\/auto ret = _idSpanMap.find(prevId);
\n\/\/\/\/\u524d\u9762\u7684\u9875\u53f7\u6ca1\u6709，\u4e0d\u5408\u5e76\u4e86
\n\/\/if (ret == _idSpanMap.end())
\n\/\/{
\n\/\/break;
\n\/\/}
\nauto ret = (Span*)_idSpanMap.get(prevId);
\nif (ret == nullptr)
\n{
\nbreak;
\n}<\/p>\n
\/\/\u524d\u9762\u76f8\u90bb\u9875\u7684span\u5728\u4f7f\u7528，\u4e0d\u5408\u5e76\u4e86
\nSpan* prevSpan = ret;
\nif (prevSpan->_isUse == true)
\n{
\nbreak;
\n}<\/p>\n
\/\/\u5408\u5e76\u51fa\u8d85\u8fc7128\u9875\u7684span\u6ca1\u529e\u6cd5\u7ba1\u7406，\u4e5f\u4e0d\u5408\u5e76
\nif (prevSpan->_n + span->_n > NPAGES – 1)
\n{
\nbreak;
\n}<\/p>\n
span->_pageId = prevSpan->_pageId;
\nspan->_n += prevSpan->_n;<\/p>\n
_spanLists[prevSpan->_n].Erase(prevSpan);
\n\/\/delete prevSpan;
\n_spanPool.Delete(prevSpan);
\n}<\/p>\n
\/\/\u5411\u540e\u5408\u5e76
\nwhile (1)
\n{
\nPAGE_ID nextId = span->_pageId + span->_n;
\n\/*auto ret = _idSpanMap.find(nextId);
\nif (ret == _idSpanMap.end())
\n{
\nbreak;
\n}*\/
\nauto ret = (Span*)_idSpanMap.get(nextId);
\nif (ret == nullptr)
\n{
\nbreak;
\n}<\/p>\n
Span* nextSpan = ret;
\nif (nextSpan->_isUse == true)
\n{
\nbreak;
\n}<\/p>\n
if (nextSpan->_n + span->_n > NPAGES – 1)
\n{
\nbreak;
\n}<\/p>\n
span->_n += nextSpan->_n;<\/p>\n
_spanLists[nextSpan->_n].Erase(nextSpan);
\n\/\/delete nextSpan;
\n_spanPool.Delete(nextSpan);
\n}<\/p>\n
_spanLists[span->_n].PushFront(span);
\nspan->_isUse = false;
\n\/\/_idSpanMap[span->_pageId] = span;
\n\/\/_idSpanMap[span->_pageId + span->_n – 1] = span;<\/p>\n
_idSpanMap.set(span->_pageId, span);
\n_idSpanMap.set(span->_pageId + span->_n – 1, span);
\n} <\/p>\n
#include"ThreadCache.h"
\n#include"CentralCache.h"<\/p>\n
void* ThreadCache::FetchFromCentralCache(size_t index, size_t size)
\n{
\n\/\/\u6162\u5f00\u59cb\u53cd\u9988\u8c03\u8282\u7b97\u6cd5
\n\/\/1.\u6700\u5f00\u59cb\u4e0d\u4f1a\u4e00\u6b21\u5411central cache\u4e00\u6b21\u6279\u91cf\u8981\u592a\u591a，\u56e0\u4e3a\u8981\u592a\u591a\u53ef\u80fd\u7528\u4e0d\u5b8c
\n\/\/2.\u5982\u679c\u4f60\u4e0d\u8981\u8fd9\u4e2asize\u5927\u5c0f\u5185\u5b58\u9700\u6c42，\u90a3\u4e48batchNum\u5c31\u4f1a\u4e0d\u65ad\u589e\u957f，\u76f4\u5230\u4e0a\u9650
\n\/\/3.size\u8d8a\u5927，\u4e00\u6b21\u5411central cache\u8981\u7684batchNum\u5c31\u8d8a\u5c0f
\n\/\/4.size\u8d8a\u5c0f，\u4e00\u6b21\u5411central cache\u8981\u7684batchNum\u5c31\u8d8a\u5927
\nsize_t batchNum =min(_freeLists[index].MaxSize(), SizeClass::NumMoveSize(size));
\nif (_freeLists[index].MaxSize() == batchNum)
\n{
\n_freeLists[index].MaxSize() += 1;\/\/\u6700\u5f00\u59cbMaxSize\u662f1，\u6240\u4ee5\u6162\u6162\u589e\u957f，\u4e00\u6b21\u589e\u957f\u4e00\u4e2a，\u8d8a\u5230\u540e\u9762，\u4e00\u6b21\u6279\u91cf\u7ed9\u7684\u5c31\u8d8a\u591a\u3002
\n}<\/p>\n
void* start = nullptr;
\nvoid* end = nullptr;
\nsize_t actualNum = CentralCache::GetInstance()->FetchRangeObj(start, end, batchNum, size);\/\/\u5b9e\u9645span\u91cc\u6302\u7684\u94fe\u8868\u7684\u5bf9\u8c61\u53ef\u80fd\u4e0d\u8db3batchNum\u4e2a
\nassert(actualNum > 0); <\/p>\n
if (actualNum == 1)
\n{
\nassert(start == end);
\nreturn start;
\n}
\nelse
\n{
\n_freeLists[index].PushRange(NextObj(start), end,actualNum-1); \/\/\u7b2c\u4e00\u4e2astart\u8981\u8fd4\u56de
\nreturn start;
\n}
\n} <\/p>\n
void* ThreadCache::Allocate(size_t size)
\n{
\nassert(size <= MAX_BYTES);
\nsize_t alignSize = SizeClass::RoundUp(size);
\nsize_t index = SizeClass::Index(size); \/\/\u8ba1\u7b97\u5728\u54ea\u4e00\u4e2a\u6876（\u81ea\u7531\u94fe\u8868）\u91cc\u9762\u53d6<\/p>\n
if (!_freeLists[index].Empty()) \/\/\u5982\u679c\u81ea\u7531\u94fe\u8868\u4e0d\u4e3a\u7a7a，\u5c31\u5728\u8fd9\u91cc\u62ff
\n{
\nreturn _freeLists[index].Pop();
\n}
\nelse
\n{
\nreturn FetchFromCentralCache(index, alignSize); \/\/\u5426\u5219\u5c31\u53bb\u4e2d\u5fc3\u7f13\u5b58\u62ff
\n}
\n}<\/p>\n
void ThreadCache::Deallocate(void* ptr, size_t size)
\n{
\nassert(ptr);
\nassert(size <= MAX_BYTES);<\/p>\n
\/\/\u627e\u5bf9\u5e94\u6620\u5c04\u7684\u81ea\u7531\u94fe\u8868\u6876，\u628a\u5bf9\u8c61\u63d2\u5165\u8fdb\u53bb
\nsize_t index = SizeClass::Index(size);
\n_freeLists[index].Push(ptr);<\/p>\n
\/\/\u5f53\u94fe\u8868\u957f\u5ea6\u5927\u4e8e\u4e00\u6b21\u6279\u91cf\u7533\u8bf7\u7684\u5185\u5b58\u65f6\u5c31\u5f00\u59cb\u8fd8\u4e00\u6bb5list\u7ed9central cache
\nif (_freeLists[index].Size() >= _freeLists[index].MaxSize())
\n{
\nListTooLong(_freeLists[index], size);
\n}
\n}<\/p>\n
void ThreadCache::ListTooLong(FreeList& list, size_t size)
\n{
\nvoid* start = nullptr;
\nvoid* end = nullptr;
\nlist.PopRange(start, end, list.MaxSize());<\/p>\n
CentralCache::GetInstance()->ReleaseListToSpans(start, size);
\n} <\/p>\n
#include"ObjectPool.h"
\n#include"ConcurrentAlloc.h"<\/p>\n
void Alloc1()
\n{
\nfor (size_t i = 0; i < 5; i++)
\n{
\nvoid* ptr = ConcurrentAlloc(6);<\/p>\n
}
\n}<\/p>\n
void Alloc2()
\n{
\nfor (size_t i = 0; i <5 ; i++)
\n{
\nvoid* ptr = ConcurrentAlloc(7);<\/p>\n
}
\n}<\/p>\n
void TLSTest()
\n{
\nstd::thread t1(Alloc1);
\nt1.join();<\/p>\n
std::thread t2(Alloc2);
\nt2.join();
\n}<\/p>\n
void TestConcurrentAlloc1()
\n{
\nvoid* p1 = ConcurrentAlloc(6);
\nvoid* p2 = ConcurrentAlloc(8);
\nvoid* p3 = ConcurrentAlloc(1);
\nvoid* p4 = ConcurrentAlloc(7);
\nvoid* p5 = ConcurrentAlloc(8);<\/p>\n
cout << p1 << endl;
\ncout << p2 << endl;
\ncout << p3 << endl;
\ncout << p4 << endl;
\ncout << p5 << endl;<\/p>\n
ConcurrentFree(p1);
\nConcurrentFree(p2);
\nConcurrentFree(p3);
\nConcurrentFree(p4);
\nConcurrentFree(p5);<\/p>\n
}<\/p>\n
void TestConcurrentAlloc2()
\n{
\nfor (size_t i = 0; i < 1024; i++)
\n{
\nvoid* p1 = ConcurrentAlloc(6);
\ncout << p1 << endl;
\n}<\/p>\n
void* p2 = ConcurrentAlloc(8);
\ncout << p2 << endl;
\n}<\/p>\n
void TestAddressShift()
\n{
\nPAGE_ID id1 = 2000;
\nPAGE_ID id2 = 2000;
\nchar* p1 = (char*)(id1 << PAGE_SHIFT);
\nchar* p2 = (char*)(id1 << PAGE_SHIFT);<\/p>\n
while (p1 < p2)
\n{
\ncout << (void*)p1 << ":" << ((PAGE_ID)p1 >> PAGE_SHIFT) << endl;
\np1 += 8;
\n}
\n}<\/p>\n
\/\/int main()
\n\/\/{
\n\/\/\/\/TestObjectPool();
\n\/\/\/\/TLSTest();
\n\/\/TestConcurrentAlloc1();
\n\/\/return 0;
\n\/\/} <\/p>\n","protected":false},"excerpt":{"rendered":"
🌈\u4e2a\u4eba\u4e3b\u9875：\u79e6jh__https:\/\/blog.csdn.net\/qinjh_?spm1010.2135.3001.5343 🔥\u00a0\u7cfb\u5217\u4e13\u680f：https:\/\/blog.csdn.net\/qinjh_\/category_13016668.html \u76ee\u5f55
\n\u4ece\u96f6\u5b9e\u73b0\u4e00\u4e2a\u9ad8\u5e76\u53d1\u5185\u5b58\u6c60
\n\u9879\u76ee\u4ecb\u7ecd
\n\u8fd9\u4e2a\u9879\u76ee\u505a\u7684\u662f\u4ec0\u4e48？\u00a0
\n\u4ec0\u4e48\u662f\u5185\u5b58\u6c60\u00a0
\n1.\u6c60\u5316\u6280\u672f\u00a0
\n2.\u5185\u5b58\u6c60\u00a0
\n3.\u5185\u5b58\u6c60\u4e3b\u8981\u89e3\u51b3\u7684\u95ee\u9898\u00a0 4.ma<\/p>\n","protected":false},"author":2,"featured_media":67553,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[55,58,190,100],"topic":[],"class_list":["post-67562","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-server","tag-c","tag-linux","tag-190","tag-100"],"yoast_head":"\n