【Kafka从成神到升仙系列四】你真的了解 Kafka 的缓存池机制嘛_kafka服务端会主动把数据放入缓存吗(1)

2401_84167086

于 2024-04-30 08:17:50 发布

阅读量282

点赞数 5

分类专栏：程序员文章标签： kafka 缓存分布式

本文链接：https://blog.csdn.net/2401_84167086/article/details/138333585

版权

程序员专栏收录该内容

176 篇文章 0 订阅

订阅专栏

// 整个BufferPool总内存大小默认32M
private final long totalMemory;
// 当前BufferPool管理的单个ByteBuffer大小，16k
private final int poolableSize;
// 因为有多线程并发分配和回收ByteBuffer，用锁控制并发，保证线程安全。
private final ReentrantLock lock;
// 对应一个ArrayDeque 队列，其中缓存了固定大小的 ByteBuffer 对象
private final Deque free;
// 此队列记录因申请不到足够空间而阻塞的线程对应的 Condition 对象
private final Deque waiters;
// 非池化可用的内存即 totalMemory 减去 free 列表中的全部 ByteBuffer 的大小
private long availableMemory;
// 构造函数
public BufferPool(long memory, int poolableSize, Metrics metrics, Time time, String metricGrpName) {
…
// 总的内存
this.totalMemory = memory;
// 默认的池外内存，就是总的内存
this.availableMemory = memory;
}
}


所以，我们一开始的 `BufferPool` 的结构如下：  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/e8e35f26077948d9844fdb9719df1ba9.png)


#### 2. allocate()


这里我们先介绍一下缓存池分配的流程：**如果你看不懂，没有关系，后面每种情况的解析及流程图，喜欢的可以点下关注吆~**

/**
* 主要为当前的batch分配内存
*
*/
public ByteBuffer allocate(int size, long maxTimeToBlockMs) throws InterruptedException {
// 1. 如果当前申请的内存大于总内存，则直接报错
if (size > this.totalMemory)
throw new IllegalArgumentException(“Attempt to allocate " + size
+ " bytes, but there is a hard limit of "
+ this.totalMemory
+ " on memory allocations.”);

// 2. 加锁
this.lock.lock();
try {
    // 3.申请内存大小恰好为16k 且free缓存池不为空
    if (size == poolableSize && !this.free.isEmpty()) {
        // 从free队列取出一个ByteBuffer
        return this.free.pollFirst();
    }

    // 4. 计算下free队列当前拥有的内存大小
    int freeListSize = this.free.size() \* this.poolableSize;
    // 如果 free + availableMemory 大于 当前的 size
    if (this.availableMemory + freeListSize >= size) {
        // 循环的将 free 队列中的 ByteBuffer 给排掉，分配给 availableMemory
        freeUp(size);
        this.availableMemory -= size;
        lock.unlock();
        return ByteBuffer.allocate(size);
    } else {
        // 5. 如果当前BufferPool不够提供申请内存大小，则需要阻塞当前线程
        int accumulated = 0;
        ByteBuffer buffer = null;
        Condition moreMemory = this.lock.newCondition();
        long remainingTimeToBlockNs = TimeUnit.MILLISECONDS.toNanos(maxTimeToBlockMs);
        // 把自己添加到等待队列中末尾，保持公平性，先来的先获取内存，防止饥饿
        this.waiters.addLast(moreMemory);
        // 循环等待直到分配成功或超时
        while (accumulated < size) {
            long startWaitNs = time.nanoseconds();
            long timeNs;
            boolean waitingTimeElapsed;
            // 当前线程阻塞等待，返回结果为false则表示阻塞超时
            waitingTimeElapsed = !moreMemory.await(remainingTimeToBlockNs,TimeUnit.NANOSECONDS);

            // 6. 申请内存大小是16k，且free缓存池有了空闲的ByteBuffer
            if (accumulated == 0 && size == this.poolableSize && !this.free.isEmpty()) {
                // 从free队列取出一个ByteBuffer
                buffer = this.free.pollFirst();
                // 计算累加器
                accumulated = size;
            } else {
                // 释放空间给非池化可用内存，并继续等待空闲空间，如果分配多了只取够size的空间
                freeUp(size - accumulated);
                int got = (int) Math.min(size - accumulated, this.availableMemory);
                // 释放非池化可用内存大小
                this.availableMemory -= got;
                // 累计分配了多少空间
                accumulated += got;
            }
        }

        // 7. 当非池化可用内存有内存或free缓存池有空闲ByteBufer且等待队列里有线程正在等待
        if (this.availableMemory > 0 || !this.free.isEmpty()) {
            if (!this.waiters.isEmpty())
                // 唤醒队列里正在等待的线程
                this.waiters.peekFirst().signal();
        }

        // 解锁
        lock.unlock();

        // 8. 说明空间足够，并且有足够空闲的了。可以执行真正的分配空间了。
        if (buffer == null)
            // 没有正好的buffer，从缓冲区外(JVM Heap)中直接分配内存
            return ByteBuffer.allocate(size);
        else
            // 直接复用free缓存池的ByteBuffer
            return buffer;
    }
} finally {
    if (lock.isHeldByCurrentThread())
        lock.unlock();
}

}


我们概况一下分配的 `4` 种情况：


**第一种：申请的内存为16KB且free缓存池有缓存可用**


此时会直接从 `free` 缓存池的队首拿出一个 `16KB` 的 `ByteBuffer` 来直接使用，等到 `ByteBuffer` 用完之后，将其 `clear()` 然后放入 `free` 缓存池的尾部，随后唤醒下一个等待内存分配的线程。  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/d44c26ef211840eab4e5ac97fbd5fbd5.png)


**第二种：申请16k且free缓存池无可用内存**


此时 free 缓存池无可用内存，只能从**可用内存中获取16k内存来分配**，用完后直接将 `ByteBuffer` 放到 free 缓存池的队尾中，并**调用 clear() 清空数据**，以便下次重复使用。


![在这里插入图片描述](https://img-blog.csdnimg.cn/56ea2895f6f34a818269d7b4e10b9b84.png)


**情况3：申请非16k且free缓存池无可用内存**


此时 free 缓存池无可用内存，且 **申请的是非16k**，只能从 **非池化可用内存(空间够分配)中获取一部分内存来分配**，用完后直接将申请到的内存空间释放到非池化可用内存中，后续会 **被 GC 掉**。


![在这里插入图片描述](https://img-blog.csdnimg.cn/0f9aeb146a6743f196c601f5c1f1ef0a.png)


**情况4：申请非16k且free缓存池有可用内存，但非池化可用内存不够**


此时 free 缓存池有可用内存，但 **申请的是非16k**，先尝试从 **free 缓存池中将 ByteBuffer 释放到非池化可用内存中，直到满足申请内存大小(size)，然后从可用内存获取对应内存大小来分配，用完后直接将申请到的内存空间释放到到非池化可用内存中，后续会被 GC 掉**。  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/3a530d1cb83848e3b2fed6af1ccce5b8.png)


#### 3. deallocate()


当使用完缓存之后，将缓存清空重新放入缓存池的操作源码如下：

// 返回缓存的操作
// 若当前的 ByteBuffer 是 16KB 的，直接放入 free 缓存池
// 若不是，则直接返还给 availableMemory
// 最后唤醒下一个等待内存分配的线程
public void deallocate(ByteBuffer buffer, int size) {
lock.lock();
try {
if (size == this.poolableSize && size == buffer.capacity()) {
// 清空
buffer.clear();
this.free.add(buffer);
} else {
this.availableMemory += size;
}
// 唤醒下一个等待内存分配的线程
Condition moreMem = this.waiters.peekFirst();
if (moreMem != null)
moreMem.signal();
} finally {
lock.unlock();
}
}


### 三、缓冲池流程图


![在这里插入图片描述](https://img-blog.csdnimg.cn/7f9d4d9acfbe4c94841c03d1d1871f13.png#pic_center)


### 四、总结


本章我们讲述了 `Kafka` 生产端为了避免频繁的 `GC`，创建了 **缓存池的机制**


当生产端申请的内存为 `16KB` 时，从缓存池中取缓存使用，非 `16KB` 则取 **不可复用的ByteBuffer** 使用


我们在生产中要尽量避免 `不可复用的ByteBuffer` 的产生，根据当前的业务去调整 `batch.size` 的大小，否则容易造成频繁的 `GC`，影响我们的线上业务。


下一章我们将会更新 **Kafka 生产端的网络 I/O 模型**


喜欢 `kafka` 的可以点个关注吆，后续会继续更新其源码文章。



![img](https://img-blog.csdnimg.cn/img_convert/d0772f6d09cb65babe6f16ba0720a970.png)
![img](https://img-blog.csdnimg.cn/img_convert/9ab3d38bedd0e47c106d9c8d2293c45e.png)
![img](https://img-blog.csdnimg.cn/img_convert/26134ebef1d2b7faa4550cfb13c5f510.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**

14436226164)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**

2401_84167086

关注

5
点赞
踩
8

收藏

觉得还不错? 一键收藏
2
评论
【Kafka从成神到升仙系列四】你真的了解 Kafka 的缓存池机制嘛_kafka服务端会主动把数据放入缓存吗(1)

/ 非池化可用的内存即 totalMemory 减去 free 列表中的全部 ByteBuffer 的大小。// 若当前的 ByteBuffer 是 16KB 的，直接放入 free 缓存池。// 此队列记录因申请不到足够空间而阻塞的线程对应的 Condition 对象。// 当前BufferPool管理的单个ByteBuffer大小，16k。// 1. 如果当前申请的内存大于总内存，则直接报错。// 默认的池外内存，就是总的内存。// 唤醒下一个等待内存分配的线程。// 返回缓存的操作。
复制链接

扫一扫