AdaptiveRecvByteBufAllocator解析

看官方说法，是一个能根据以往接受的消息进行计算，动态调整内存，利用CPU资源来换取内存资源，具体的实现策略如下：根据之前Channel接收到的数据包大小进行计算，如果连续填充满接收缓冲区的可写空间，则动态扩展容量。如果连续2次接收到的数据包都小于指定值，则收缩当前的容量，以节约内存。具体使用时，代码如下：

option(ChannelOption.RCVBUF_ALLOCATOR,new AdaptiveRecvByteBufAllocator(DEFAULT_MINIMUM,DEFAULT_INITIAL,DEFAULT_MAXIMUM))或者option(ChannelOption.RCVBUF_ALLOCATOR,new AdaptiveRecvByteBufAllocator())

接下来看源码：

public class AdaptiveRecvByteBufAllocator extends DefaultMaxMessagesRecvByteBufAllocator {
    //接收缓冲区最小长度下限
    static final int DEFAULT_MINIMUM = 64;
    //接收缓冲区初始化
    static final int DEFAULT_INITIAL = 2048;
    //接收缓冲区最大长度上限
    static final int DEFAULT_MAXIMUM = 65536;
    //扩容增长量
    private static final int INDEX_INCREMENT = 4;
    //扩容减少量
    private static final int INDEX_DECREMENT = 1;
    private static final int[] SIZE_TABLE;
    /** @deprecated */
    @Deprecated
    public static final AdaptiveRecvByteBufAllocator DEFAULT;
    private final int minIndex;
    private final int maxIndex;
    private final int initial;
    //入参是一个大小，然后利用二分查找法对该数组进行size的定位，目标是为了找出该size值在数组中的下标位置，主要是为了初始化minIndex、maxIndex这两个参数
    private static int getSizeTableIndex(int size) {
        int low = 0;
        int high = SIZE_TABLE.length - 1;

        while(high >= low) {
            if (high == low) {
                return high;
            }

            int mid = low + high >>> 1;
            int a = SIZE_TABLE[mid];
            int b = SIZE_TABLE[mid + 1];
            if (size > b) {
                low = mid + 1;
            } else {
                if (size >= a) {
                    if (size == a) {
                        return mid;
                    }

                    return mid + 1;
                }

                high = mid - 1;
            }
        }

        return low;
    }

    public AdaptiveRecvByteBufAllocator() {
        this(64, 2048, 65536);
    }

    public AdaptiveRecvByteBufAllocator(int minimum, int initial, int maximum) {
        ObjectUtil.checkPositive(minimum, "minimum");
        //minimum不能大于初始化长度initial，初始化长度initial不能超过maximum
        if (initial < minimum) {
            throw new IllegalArgumentException("initial: " + initial);
        } else if (maximum < initial) {
            throw new IllegalArgumentException("maximum: " + maximum);
        } else {
            int minIndex = getSizeTableIndex(minimum);
            if (SIZE_TABLE[minIndex] < minimum) {
                this.minIndex = minIndex + 1;
            } else {
                this.minIndex = minIndex;
            }

            int maxIndex = getSizeTableIndex(maximum);
            if (SIZE_TABLE[maxIndex] > maximum) {
                this.maxIndex = maxIndex - 1;
            } else {
                this.maxIndex = maxIndex;
            }

            this.initial = initial;
        }
    }

    public Handle newHandle() {
        return new AdaptiveRecvByteBufAllocator.HandleImpl(this.minIndex, this.maxIndex, this.initial);
    }

    public AdaptiveRecvByteBufAllocator respectMaybeMoreData(boolean respectMaybeMoreData) {
        super.respectMaybeMoreData(respectMaybeMoreData);
        return this;
    }
    /*
    分配了一个int类型的数组，并进行该数组的初始化处理，从实现来看，该数组的长度是53，前32位是16的倍数，value值是从16开始，到512；从第33位开始，值是前一位的两倍，即从1024、2048、到最大值1073741824
    */
    static {
        List<Integer> sizeTable = new ArrayList();

        int i;
        for(i = 16; i < 512; i += 16) {
            sizeTable.add(i);
        }

        for(i = 512; i > 0; i <<= 1) {
            sizeTable.add(i);
        }

        SIZE_TABLE = new int[sizeTable.size()];

        for(i = 0; i < SIZE_TABLE.length; ++i) {
            SIZE_TABLE[i] = (Integer)sizeTable.get(i);
        }

        DEFAULT = new AdaptiveRecvByteBufAllocator();
    }

    private final class HandleImpl extends MaxMessageHandle {
        private final int minIndex;
        private final int maxIndex;
        private int index;
　　　　　　　　//每次调容最关键的参数
        private int nextReceiveBufferSize;
        private boolean decreaseNow;

        HandleImpl(int minIndex, int maxIndex, int initial) {
            super(AdaptiveRecvByteBufAllocator.this);
            this.minIndex = minIndex;
            this.maxIndex = maxIndex;
　　　　　　　　　//用initial获取一开始初始化缓冲的下标，在根据SIZE_TABLE查找应分配的BufferSize。
            this.index = AdaptiveRecvByteBufAllocator.getSizeTableIndex(initial);
            this.nextReceiveBufferSize = AdaptiveRecvByteBufAllocator.SIZE_TABLE[this.index];
        }

        public void lastBytesRead(int bytes) {
            if (bytes == this.attemptedBytesRead()) {
                this.record(bytes);
            }

            super.lastBytesRead(bytes);
        }

        public int guess() {
            return this.nextReceiveBufferSize;
        }
        /*
        
        该方法的参数是一次读取操作中实际读取到的数据大小，将其与nextReceiveBufferSize 进行比较，如果实际字节数actualReadBytes大于等于该值，则立即更新nextReceiveBufferSize ，其更新后的值与INDEX_INCREMENT有关。INDEX_INCREMENT为默认常量，值为4。也就是说在扩容时会一次性增大多一些，以保证下次有足够空间可以接收数据。而相对扩容的策略，缩容策略则实际保守些，常量为INDEX_INCREMENT，值为1，同样也是进行对比， 但不同的是，若实际字节小于所用nextReceiveBufferSize，并不会立马进行大小调整，而是先把 decreaseNow 设置为true，如果下次仍然小于，则才会减少nextReceiveBufferSize的大小
        */
        private void record(int actualReadBytes) {
            if (actualReadBytes <= AdaptiveRecvByteBufAllocator.SIZE_TABLE[Math.max(0, this.index - 1)]) {
                if (this.decreaseNow) {
                    this.index = Math.max(this.index - 1, this.minIndex);
                    this.nextReceiveBufferSize = AdaptiveRecvByteBufAllocator.SIZE_TABLE[this.index];
                    this.decreaseNow = false;
                } else {
                    this.decreaseNow = true;
                }
            } else if (actualReadBytes >= this.nextReceiveBufferSize) {
                this.index = Math.min(this.index + 4, this.maxIndex);
                this.nextReceiveBufferSize = AdaptiveRecvByteBufAllocator.SIZE_TABLE[this.index];
                this.decreaseNow = false;
            }

        }

        public void readComplete() {
            this.record(this.totalBytesRead());
        }
    }
}