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

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

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

需要这份系统化资料的朋友，可以戳这里获取

竟然提到了缓存池，那么就不得不分析一下 BufferPool 的源码

public class BufferPool {
  // 整个BufferPool总内存大小 默认32M
  private final long totalMemory;
  // 当前BufferPool管理的单个ByteBuffer大小，16k 
  private final int poolableSize;
  // 因为有多线程并发分配和回收ByteBuffer，用锁控制并发，保证线程安全。
  private final ReentrantLock lock;
  // 对应一个ArrayDeque<ByteBuffer> 队列，其中缓存了固定大小的 ByteBuffer 对象
  private final Deque<ByteBuffer> free;
  // 此队列记录因申请不到足够空间而阻塞的线程对应的 Condition 对象
  private final Deque<Condition> 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 的结构如下：

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 缓存池的尾部，随后唤醒下一个等待内存分配的线程。

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

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

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

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

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

此时 free 缓存池有可用内存，但 申请的是非16k，先尝试从 free 缓存池中将 ByteBuffer 释放到非池化可用内存中，直到满足申请内存大小(size)，然后从可用内存获取对应内存大小来分配，用完后直接将申请到的内存空间释放到到非池化可用内存中，后续会被 GC 掉。

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();
    }
}

三、缓冲池流程图

四、总结

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

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

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

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

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

需要这份系统化资料的朋友，可以戳这里获取

-7j6DyTMe-1714990948825)]

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

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

需要这份系统化资料的朋友，可以戳这里获取