Netty之Buffer（二）ByteBufAllocator

最新推荐文章于 2023-08-15 04:27:07 发布
最新推荐文章于 2023-08-15 04:27:07 发布
阅读量744 收藏
点赞数 1
分类专栏： Netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43257196/article/details/105033635
版权

ByteBufAllocator是ByteBuf的分配器，负责创建ByteBuf对象，他主要有三个子类：

  1. PreferHeapByteBufAllocator ，倾向创建 Heap ByteBuf 的分配器。
  2. PooledByteBufAllocator ，基于内存池的 ByteBuf 的分配器。
  3. UnpooledByteBufAllocator ，普通的 ByteBuf 的分配器。
    这里先看PreferHeapByteBufAllocator。

buffer() 方法，创建一个 ByteBuf 对象。实现类决定具体创建的是 Heap ByteBuf 还是 Direct ByteBuf 。

/**
 * Allocate a {@link ByteBuf}. If it is a direct or heap buffer
 * depends on the actual implementation.
 */
ByteBuf buffer();
ByteBuf buffer(int initialCapacity);
ByteBuf buffer(int initialCapacity, int maxCapacity);

ioBuffer() 方法，创建一个用于 IO 操作的 ByteBuf 对象。
对于 IO 操作来说，倾向于 Direct ByteBuf ，性能更优。

/**
 * Allocate a {@link ByteBuf}, preferably a direct buffer which is suitable for I/O.
 */
ByteBuf ioBuffer();
ByteBuf ioBuffer(int initialCapacity);
ByteBuf ioBuffer(int initialCapacity, int maxCapacity);

heapBuffer() 方法，创建一个 Heap Buffer 对象:

/**
 * Allocate a heap {@link ByteBuf}.
 */
ByteBuf heapBuffer();
ByteBuf heapBuffer(int initialCapacity);
ByteBuf heapBuffer(int initialCapacity, int maxCapacity);

directBuffer() 方法，创建一个 Direct Buffer 对象:

/**
 * Allocate a direct {@link ByteBuf} with the given initial capacity.
 */
ByteBuf directBuffer(int initialCapacity);
ByteBuf directBuffer(int initialCapacity, int maxCapacity);
CompositeByteBuf compositeBuffer();

compositeBuffer() 方法，创建一个 Composite ByteBuf 对象。实现类决定具体创建的是 Heap ByteBuf 还是 Direct ByteBuf ：

/**
 * Allocate a {@link CompositeByteBuf}.
 * If it is a direct or heap buffer depends on the actual implementation.
 */
CompositeByteBuf compositeBuffer();
CompositeByteBuf compositeBuffer(int maxNumComponents);

compositeHeapBuffer() 方法，创建一个 Composite Heap ByteBuf 对象：

/**
 * Allocate a heap {@link CompositeByteBuf}.
 */
CompositeByteBuf compositeHeapBuffer();
CompositeByteBuf compositeHeapBuffer(int maxNumComponents);

compositeDirectBuffer(…) 方法，创建一个 Composite Direct ByteBuf 对象：

/**
 * Allocate a direct {@link CompositeByteBuf}.
 */
CompositeByteBuf compositeDirectBuffer();
CompositeByteBuf compositeDirectBuffer(int maxNumComponents);

isDirectBufferPooled() 方法，是否基于 Direct ByteBuf 对象池：

/**
 * Returns {@code true} if direct {@link ByteBuf}'s are pooled
 */
boolean isDirectBufferPooled();

calculateNewCapacity(int minNewCapacity, int maxCapacity) 方法，在 ByteBuf 扩容时，计算新的容量，该容量的值在 [minNewCapacity, maxCapacity] 范围内：

/**
 * Calculate the new capacity of a {@link ByteBuf} that is used when a {@link ByteBuf} needs to expand by the
 * {@code minNewCapacity} with {@code maxCapacity} as upper-bound.
 */
int calculateNewCapacity(int minNewCapacity, int maxCapacity);

AbstractByteBufAllocator，实现 ByteBufAllocator 接口及ByteBufAllocator 抽象实现类，为 PooledByteBufAllocator 和 UnpooledByteBufAllocator 提供公共的方法。
构造方法：

/**
 * 是否倾向创建 Direct ByteBuf
 */
private final boolean directByDefault;
/**
 * 空 ByteBuf 缓存
 */
private final ByteBuf emptyBuf;

/**
 * Instance use heap buffers by default
 */
protected AbstractByteBufAllocator() {
    this(false);
}

/**
 * Create new instance
 *
 * @param preferDirect {@code true} if {@link #buffer(int)} should try to allocate a direct buffer rather than
 *                     a heap buffer
 */
protected AbstractByteBufAllocator(boolean preferDirect) {
    directByDefault = preferDirect && PlatformDependent.hasUnsafe(); // 支持 Unsafe
    emptyBuf = new EmptyByteBuf(this);
}

directByDefault 属性: 是否倾向创建 Direct ByteBuf 。有一个前提是需要支持 Unsafe 操作。
emptyBuf 属性：空 ByteBuf 缓存对象。用于 buffer() 等方法，创建空 ByteBuf 对象时。

buffer：
根据 directByDefault 的值，调用 directBuffer() 方法，还是调用 heapBuffer() 方法。

@Override
public ByteBuf buffer() {
    if (directByDefault) {
        return directBuffer();
    }
    return heapBuffer();
}
@Override
public ByteBuf buffer(int initialCapacity) {
    if (directByDefault) {
        return directBuffer(initialCapacity);
    }
    return heapBuffer(initialCapacity);
}
@Override
public ByteBuf buffer(int initialCapacity, int maxCapacity) {
    if (directByDefault) {
        return directBuffer(initialCapacity, maxCapacity);
    }
    return heapBuffer(initialCapacity, maxCapacity);
}

ioBuffer：
根据是否支持 Unsafe 操作的情况，调用 directBuffer() 方法，还是调用 heapBuffer() 方法。

/**
 * 默认容量大小
 */
static final int DEFAULT_INITIAL_CAPACITY = 256;

@Override
public ByteBuf ioBuffer() {
    if (PlatformDependent.hasUnsafe()) {
        return directBuffer(DEFAULT_INITIAL_CAPACITY);
    }
    return heapBuffer(DEFAULT_INITIAL_CAPACITY);
}

@Override
public ByteBuf ioBuffer(int initialCapacity) {
    if (PlatformDependent.hasUnsafe()) {
        return directBuffer(initialCapacity);
    }
    return heapBuffer(initialCapacity);
}

@Override
public ByteBuf ioBuffer(int initialCapacity, int maxCapacity) {
    if (PlatformDependent.hasUnsafe()) {
        return directBuffer(initialCapacity, maxCapacity);
    }
    return heapBuffer(initialCapacity, maxCapacity);
}

heapBuffer

/**
 * 默认最大容量大小，无限。
 */
static final int DEFAULT_MAX_CAPACITY = Integer.MAX_VALUE;

@Override
public ByteBuf heapBuffer() {
    return heapBuffer(DEFAULT_INITIAL_CAPACITY, DEFAULT_MAX_CAPACITY);
}

@Override
public ByteBuf heapBuffer(int initialCapacity) {
    return heapBuffer(initialCapacity, DEFAULT_MAX_CAPACITY);
}

@Override
public ByteBuf heapBuffer(int initialCapacity, int maxCapacity) {
    // 空 ByteBuf 对象
    if (initialCapacity == 0 && maxCapacity == 0) {
        return emptyBuf;
    }
    validate(initialCapacity, maxCapacity); // 校验容量的参数
    // 创建 Heap ByteBuf 对象
    return newHeapBuffer(initialCapacity, maxCapacity);
}

最终调用 newHeapBuffer(int initialCapacity, int maxCapacity) 抽象方法，创建 Heap ByteBuf 对象。因为是否基于对象池的方式，创建 Heap ByteBuf 对象的实现会不同，所以需要抽象。：

/**
 * Create a heap {@link ByteBuf} with the given initialCapacity and maxCapacity.
 */
protected abstract ByteBuf newHeapBuffer(int initialCapacity, int maxCapacity);

directBuffer：

@Override
public ByteBuf directBuffer() {
    return directBuffer(DEFAULT_INITIAL_CAPACITY, DEFAULT_MAX_CAPACITY);
}

@Override
public ByteBuf directBuffer(int initialCapacity) {
    return directBuffer(initialCapacity, DEFAULT_MAX_CAPACITY);
}

@Override
public ByteBuf directBuffer(int initialCapacity, int maxCapacity) {
    // 空 ByteBuf 对象
    if (initialCapacity == 0 && maxCapacity == 0) {
        return emptyBuf;
    }
    validate(initialCapacity, maxCapacity); // 校验容量的参数
    // 创建 Direct ByteBuf 对象
    return newDirectBuffer(initialCapacity, maxCapacity);
}

最终调用 newDirectBuffer(int initialCapacity, int maxCapacity) 抽象方法，创建 Direct ByteBuf 对象，因为是否基于对象池的方式，创建 Direct ByteBuf 对象的实现会不同，所以需要抽象。:

/**
 * Create a direct {@link ByteBuf} with the given initialCapacity and maxCapacity.
 */
protected abstract ByteBuf newDirectBuffer(int initialCapacity, int maxCapacity);

compositeBuffer，根据 directByDefault 的值，调用compositeDirectBuffer() 方法，还是调用 compositeHeapBuffer() 方法。：

@Override
public CompositeByteBuf compositeBuffer() {
    if (directByDefault) {
        return compositeDirectBuffer();
    }
    return compositeHeapBuffer();
}

@Override
public CompositeByteBuf compositeBuffer(int maxNumComponents) {
    if (directByDefault) {
        return compositeDirectBuffer(maxNumComponents);
    }
    return compositeHeapBuffer(maxNumComponents);
}

compositeHeapBuffer，创建 CompositeByteBuf 对象，并且方法参数 direct 为 false ，表示 Heap 类型。调用 toLeakAwareBuffer(CompositeByteBuf) 方法，装饰成 LeakAware 的 ByteBuf 对象。：

/**
 * Composite ByteBuf 可包含的 ByteBuf 的最大数量
 */
static final int DEFAULT_MAX_COMPONENTS = 16;

@Override
public CompositeByteBuf compositeHeapBuffer() {
    return compositeHeapBuffer(DEFAULT_MAX_COMPONENTS);
}

@Override
public CompositeByteBuf compositeHeapBuffer(int maxNumComponents) {
    return toLeakAwareBuffer(new CompositeByteBuf(this, false, maxNumComponents));
}

compositeDirectBuffer：

@Override
public CompositeByteBuf compositeDirectBuffer() {
    return compositeDirectBuffer(DEFAULT_MAX_COMPONENTS);
}

@Override
public CompositeByteBuf compositeDirectBuffer(int maxNumComponents) {
    return toLeakAwareBuffer(new CompositeByteBuf(this, true, maxNumComponents));
}

创建 CompositeByteBuf 对象，并且方法参数 direct 为 true ，表示 Direct 类型。
调用 toLeakAwareBuffer(CompositeByteBuf) 方法，装饰成 LeakAware 的 ByteBuf 对象。
calculateNewCapacity：

/**
 * 扩容分界线，4M
 */
static final int CALCULATE_THRESHOLD = 1048576 * 4; // 4 MiB page

 @Override
 public int calculateNewCapacity(int minNewCapacity, int maxCapacity) {
     if (minNewCapacity < 0) {
         throw new IllegalArgumentException("minNewCapacity: " + minNewCapacity + " (expected: 0+)");
     }
     if (minNewCapacity > maxCapacity) {
         throw new IllegalArgumentException(String.format(
                 "minNewCapacity: %d (expected: not greater than maxCapacity(%d)",
                 minNewCapacity, maxCapacity));
     }
     final int threshold = CALCULATE_THRESHOLD; // 4 MiB page
 
     //  等于 threshold ，直接返回 threshold 。
     if (minNewCapacity == threshold) {
         return threshold;
     }
 
     //  超过 threshold ，增加 threshold ，不超过 maxCapacity 大小。
     // If over threshold, do not double but just increase by threshold.
     if (minNewCapacity > threshold) {
         int newCapacity = minNewCapacity / threshold * threshold;
         if (newCapacity > maxCapacity - threshold) { // 不超过 maxCapacity
             newCapacity = maxCapacity;
         } else {
             newCapacity += threshold;
         }
         return newCapacity;
     }
 
     //  未超过 threshold ，从 64 开始两倍计算，不超过 4M 大小。
     // Not over threshold. Double up to 4 MiB, starting from 64.
     int newCapacity = 64;
     while (newCapacity < minNewCapacity) {
         newCapacity <<= 1;
     }
     return Math.min(newCapacity, maxCapacity);
 }

PreferHeapByteBufAllocator，实现 ByteBufAllocator 接口，倾向创建 Heap ByteBuf 的分配器。所以buffer() 和 ioBuffer() 和 compositeBuffer() 方法，创建的都是 Heap ByteBuf 对象:

/**
 * 真正的分配器对象
 */
private final ByteBufAllocator allocator;

public PreferHeapByteBufAllocator(ByteBufAllocator allocator) {
    this.allocator = ObjectUtil.checkNotNull(allocator, "allocator");
}

@Override
public ByteBuf buffer() {
    return allocator.heapBuffer();
}

@Override
public ByteBuf ioBuffer() {
    return allocator.heapBuffer();
}

@Override
public CompositeByteBuf compositeBuffer() {
    return allocator.compositeHeapBuffer();
}
究极纲要
关注
专栏目录
Netty源码之ByteBufAllocator
m0_37343985的博客
09-30 372
内存分配管理器有个最顶层的抽象叫做ByteBuAllocator，负责分配所有的内存，我们接下来看一下它有哪些功能： ByteBuf buffer(); /** * Allocate a {@link ByteBuf} with the given initial capacity. * If it is a direct or heap buffer depen...
Netty Buffer（缓冲）
DavidChen的博客
12-11 2871
正如我们先前所指出的，网络数据的基本单位永远是 byte(字节)。Java NIO 提供 ByteBuffer 作为字节的容器，但这个类是过于复杂，有点 难以使用。 Netty 中 ByteBuffer 替代是 ByteBuf，一个强大的实现，解决 JDK 的 API 的限制，以及为网络应用程序开发者一个更好的工具。 但 ByteBuf 并不仅仅暴露操作一个字节序列的方法;这也是专门的Netty
Netty之Buffer（三）ByteBufAllocator
weixin_43257196 的博客
03-24 848
这次看PooledByteBufAllocator基于内存池的 ByteBuf 的分配器。 而 PooledByteBufAllocator 的内存池，是基于 Jemalloc 算法进行分配管理。Netty中Jemalloc PooledByteBufAllocatorMetric，实现 ByteBufAllocatorMetric 接口，PooledByteBufAllocator Metric...
Netty内存管理器ByteBufAllocator及内存分配
weixin_30908941的博客
08-02 285
ByteBufAllocator 内存管理器: 　　Netty 中内存分配有一个最顶层的抽象就是ByteBufAllocator，负责分配所有ByteBuf 类型的内存。功能其实不是很多，主要有以下几个重要的API： public interface ByteBufAllocator {/**分配一块内存，自动判断是否分配堆内内存或者堆外内存。 * Allocate ...
Netty源码分析之ByteBufAllocator
solayang的博客
11-02 430
一、ByteBufAllocator 前文分析可知ByteBufAllocator接口是ByteBuf的分配器，主要用来分配各种ByteBuf对象，本文将重点分析Allocator的分配过程。 接口定义： package io.netty.buffer; public interface ByteBufAllocator { ByteBufAllocator DEFAULT = ByteBufUtil.DEFAULT_ALLOCATOR; ByteBuf buffer(); Byt
Netty之内存分配器ByteBufAllocator
学无止境
01-15 1979
目录 内存分配器继承体系 ByteBufAllocator AbstractByteBufAllocator UnpooledByteBufAllocator newHeapBuffer newDirectBuffer PooledByteBufAllocator PoolThreadLocalCache PoolArena arena分配内存流程 内存分配器继承体系 ...
Netty(2)：核心部件：Buffer 缓冲器
Al_assad的博客
03-05 894
Netty 核心部件：Buffer 缓冲器JDK NIO 提供了 ByteBuffer 作为字节数据容器，但是实际使用过程会比较繁琐，特别是读写切换；Netty 提供了自己的缓冲区实现 BytedBuf ，用于简化字节缓冲区的使用；JDK ByteBuffer 和 Netty ByteBuf 一个很大的区别是：JDK ByteBuffer 有 4 个索引（mark、position、limit、c...
Netty之MessageToByteEncoder
zsj777的专栏
05-16 1252
Netty提供了一个特殊的ChannelHandler来专门处理编码逻辑，不需要每一次将响应写到对端的时候都调用一次编码逻辑进行编码，也不需要自行创建ByteBuf。这个类被叫作MessageToByteEncoder，从字面意思可以看出，它的功能就是将对象转换到二进制数据。 使用MessageToByteEncoder来实现编码逻辑的过程如下。 PacketEncoder继承自MessageToByteEncoder，泛型参数Packet表示这个类的作用是实现Packet类型对象到二进制.
Java网络编程--Netty中的ByteBuf
一个无限死循环的博客
10-06 1013
由于JDK中提供的ByteBuffer无法动态扩容，并且API使用复杂等原因，Netty中提供了ByteBuf。 Bytebuf的API操作更加便捷，可以动态扩容，提供了多种ByteBuf的实现，以及高效的零拷贝机制。 ByteBuf的操作 ByteBuf有三个重要的属性：capacity容量，readerIndex读取位置，writerIndex写入位置 提供了readerIndex和weite...
Netty之ByteBuf相关API
zsj777的专栏
04-15 618
package com.example.demo.util; import io.netty.buffer.ByteBuf; import io.netty.buffer.ByteBufAllocator; public class ByteBufTest { public static void main(String[] args) { //初始容量9 最大容量100 ByteBuf buf = ByteBufAllocator.DEFAULT.buff.
Netty之Buffer（四）ByteBufAllocator
weixin_43257196 的博客
03-26 405
这会看ByteBufAllocator最后一个子类：UnpooledByteBufAllocator，不基于内存池的ByteBuf分配器。
ByteBufAllocator 源码分析（三十四）
nandao158的博客
03-17 287
ByteBufAllocator ByteBufAllocator 是 Netty 内存分配最顶层的抽象，负责分配所有类型的内存。 ByteBuf buffer(); //直接分配一块内存，是使用 direct 还是 heap 取决于子类实现 ByteBuf ioBuffer(); //尽可能地分配一块堆外直接内存，如果系统不支持则分配堆内内存ByteBuf heapBuffer();// heap 内存分配 ByteBuf directBuffer();// direct 内存分配 在
netty 源码解读二 ByteBufAllocator 接口
firebolt100的博客
05-09 660
在上一篇 netty 源码解读之一 ByteBuf 接口 中我们解读了一遍 ByteBuf 源码，应该对这个 netty 中最核心的缓存数据结构有所了解了。但我们在前文发现 ByteBuf 中没有用于创建 ByteBuf 本身的方法，今天我们就来解读一下 netty 中用于创建 ByteBuf 的辅助接口 ByteBufAllocator 及其体系结构。...
netty源码阅读之ByteBuf之内存分配器ByteBufAllocator
翻身咸鱼的博客
08-23 3654
我们分三部分讲解ByteBufAllocator： 1、ByteBufAllocator功能 2、AbstractByteBufAllocator 3、ByteBufAllocator两大子类   一、ByteBufAllocator功能 查看ByteBufAllocator源码： /** * Implementations are responsible to allocat...
Netty源码之PooledByteBufAllocator
m0_37343985的博客
09-30 973
在这个类中我们主要从下面这个方法开始看： protected ByteBuf newDirectBuffer(int initialCapacity, int maxCapacity) { //从当前线程中拿到一个cache对象 PoolThreadCache cache = threadCache.get(); //从cache中获得内存管理的顶层“竞技场” ...
[Netty源码] ByteBufAllocator内存管理器相关问题 (十一)
959
04-14 634
[Netty源码] ByteBufAllocator内存管理器相关问题 (十一)
PooledByteBufAllocator
yjh314的专栏
12-16 2607
/* * Copyright 2012 The Netty Project * * The Netty Project licenses this file to you under the Apache License, * version 2.0 (the "License"); you may not use this file except in compliance * wit
Netty学习之ByteBuf
曾经沧海难为水，除却巫山不是云
10-10 844
Netty学习之ByteBuf 前言 在网络中传输的基本单元是字节byte，虽然在NIO中提供了一个ByteBuffer作为字节的容器，不过由于ByteBuffer比较难使用，所以Netty自己实现了一个，ByteBuf，并且提供了比较灵活的操作方式以及操作工具，本节我们将详细学习这一部分的知识。 ByteBuf 在Netty中，数据通过ByteBuf以及ByteBufHolder来进行操作，By...
Netty详解（一）：ByteBuf介绍
最新发布
在都市的雨幕下找寻自我
08-15 537
每当需要传输数据时，就必须有一个buffer缓冲区。Java NIO API自带的ByteBuffer操作繁琐，没有自动回收机制。 Netty的ByteBuf等同于JDK的ByteBuffer，在进行channel数据传输时，ByteBuf缓冲区组件相比于ByteBuffer更加快捷更加高效地操作内存缓冲区。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值