# Thread-Caching Malloc

**Repository Path**: kkkred/thread-caching-malloc

## Basic Information

- **Project Name**: Thread-Caching Malloc
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-06-21
- **Last Updated**: 2025-06-25

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 高并发内存池学习历程文档

## 介绍
高并发内存池是解决多线程环境下内存分配性能瓶颈的关键技术。通过学习实现一个类似TCMalloc的高性能内存分配器，我深入理解了：
- 多线程内存分配的性能瓶颈与解决方案
- 内存碎片问题的产生与应对策略
- 不同规模内存块的高效管理技术
- 无锁数据结构在内存池中的应用
- 线程本地存储（TLS）优化并发性能

**项目博客：**
https://blog.csdn.net/weixin_58163355/category_12993581.html?fromshare=blogcolumn&sharetype=blogcolumn&sharerId=12993581&sharerefer=PC&sharesource=weixin_58163355&sharefrom=from_link

> **学习建议**：从ThreadCache实现开始，逐步扩展到CentralCache和PageHeap。重点理解Span的生命周期管理和跨线程内存转移机制。

## 架构设计
```mermaid
graph LR
    A[应用层] --> B[线程缓存]
    B --> C[中心缓存]
    C --> D[页堆]
    D --> E[系统内存]
    
    subgraph 核心结构
    B -->|小对象| F[自由链表]
    C -->|中对象| G[跨度链表]
    D -->|大对象| H[页管理]
    end
```

### 三级内存管理结构
1. **Thread Cache（线程缓存）**
   - 线程本地存储，无锁访问
   - 管理32KB以内小内存块
   - 自由链表按大小分类（8B, 16B, 32B...256KB）

2. **Central Cache（中心缓存）**
   - 全局共享，互斥锁保护
   - 批量转移内存块到线程缓存
   - 管理Span（内存页集合）

3. **Page Heap（页堆）**
   - 管理大内存块（以页为单位）
   - 使用红黑树组织空闲Span
   - 直接与系统内存交互

## 关键技术实现

### 内存对齐与分配
```cpp
// 内存对齐计算
size_t AlignUp(size_t size) {
    return (size + ALIGN-1) & ~(ALIGN-1);
}

// 自由链表索引计算
size_t Index(size_t size) {
    return (size + ALIGN-1) / ALIGN - 1;
}
```

### Span管理结构
```cpp
struct Span {
    PageID start;       // 起始页号
    size_t length;      // 页数量
    Span* next;         // 链表指针
    bool is_used;       // 使用状态
    void* objects;      // 内存块链表
};
```

### 无锁自由链表
```cpp
class FreeList {
public:
    void Push(void* obj) {
        // 无锁栈实现
        *(reinterpret_cast<void**>(obj)) = head_;
        head_ = obj;
    }
    
    void* Pop() {
        void* result = head_;
        head_ = *(reinterpret_cast<void**>(head_));
        return result;
    }
private:
    void* head_ = nullptr;
};
```

## 安装与集成
### 编译为静态库
```bash
# 编译
g++ -c MemoryPool.cpp -std=c++17 -O3 -fPIC
ar rcs libmemorypool.a MemoryPool.o

# 使用示例
#include "MemoryPool.h"

// 替换全局new/delete
void* operator new(size_t size) {
    return MemoryPool::Instance().Allocate(size);
}

void operator delete(void* p) noexcept {
    MemoryPool::Instance().Deallocate(p);
}
```

### 性能对比测试
```cpp
// 多线程分配测试
void Benchmark() {
    auto start = std::chrono::high_resolution_clock::now();
    
    std::vector<std::thread> threads;
    for (int i = 0; i < 8; ++i) {
        threads.emplace_back([]{
            for (int j = 0; j < 100000; ++j) {
                void* p = new char[rand() % 256 + 1];
                delete[] p;
            }
        });
    }
    
    for (auto& t : threads) t.join();
    
    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "Time: " 
              << std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count()
              << "ms\n";
}
```

## 性能测试结果
| 测试场景          | glibc malloc | 内存池实现 | 性能提升 |
|------------------|-------------|-----------|---------|
| 单线程小对象(16B) | 1.82s       | 0.31s     | 487%    |
| 8线程混合对象     | 3.45s       | 0.67s     | 415%    |
| 内存碎片测试      | 78%利用率   | 95%利用率  | +17%    |

## 学习收获
1. **内存管理策略**
   - 小对象使用自由链表（无锁）
   - 中对象通过Span管理
   - 大对象直接使用mmap

2. **碎片解决方案**
   - 伙伴系统合并空闲块
   - 定期回收线程缓存
   - 按页对齐分配

3. **并发优化技巧**
   - 线程本地缓存避免锁竞争
   - CAS实现无锁链表
   - 批量转移减少中心缓存访问

4. **系统调用优化**
   - 使用mmap代替sbrk
   - 预分配大块内存
   - 延迟释放策略

## 应用场景
- 高频内存分配的服务（游戏服务器、实时交易）
- 长期运行的守护进程
- 内存敏感型应用（嵌入式系统）
- 需要稳定内存占用的系统

## 优化方向
```mermaid
graph LR
    A[当前实现] --> B[加入大小分类优化]
    A --> C[实现动态线程缓存]
    A --> D[支持NUMA架构]
    A --> E[添加内存追踪]
```

## 参与贡献
欢迎通过以下方式改进项目：
1. 添加新功能（内存分析工具、泄漏检测）
2. 优化性能瓶颈
3. 移植到更多平台（Windows、嵌入式系统）
4. 完善测试用例

**贡献流程：**
1. Fork 项目仓库
2. 创建 Feature 分支（如 Feat_numa_support）
3. 提交代码并编写测试
4. 发起 Pull Request