Jetty源码-IO-BufferBufferPool

最新推荐文章于 2021-12-18 20:12:03 发布

weixin_34302798

最新推荐文章于 2021-12-18 20:12:03 发布

阅读量160

点赞数

文章标签： python

原文链接：https://my.oschina.net/robinyao/blog/403334

版权

2019独角兽企业重金招聘Python工程师标准>>>

继续上文Jetty源码-IO-BufferUtil ,接着讲解下Jetty ByteBufferPool的实现。

主要介绍ArrayByteBufferPool的实现，大概的原理是用Bucket数据来放要池化的ByteBuffer。桶的结构包含了它要池化ByteBuffer容量的大小Size 和一个Queue （这里采用的是ConcurrentLinkedQueue,线程安全）。一个ByteBufferPool包含了两个Bucket[]，一个用来放direct类型的ByteBuffer,一个用来放Heap类型的ByteBuffer。ByteBufferPool初始化的时候会把两个桶的每个成员都初始化。一个Bucket盛放对应相应capacity大小的的ByteBuffer。比如我们ByteBufferPool池化可以放置最大容量为1024*60 到最小容量为0的ByteBuffer。对应的Bucket数组初始化就是60个桶，从 1024大小的，2048大小的，3072大小的.....1024*60大小的桶，当我们需要ByteBuffer时，我们只需根据容量到相应的桶中的Queue取出来即可。

以下是具体代码

接口类：

public interface ByteBufferPool {

    /**
     * 获取指定大小的ByteBuffer.
     * @param size
     * @param direct  是否用direct内存
     * @return
     */
    public ByteBuffer acquire(int size,boolean direct);

    /**
     * 返还ByteBuffer,使之重用
     * @param buffer
     */
    public void release(ByteBuffer buffer);
    //ByteBufferPool的工具类，我们可以方便的用它来操作ByteBufferPool,当然不用也可以，大家可以先直接跳过
    //因为这个类有点会误导大家的思路。可以直接看ArrayByteBufferPool的实现就OK
    public static class Lease{
        private final ByteBufferPool byteBufferPool;
        private final List<ByteBuffer> buffers;
        private final List<Boolean>recycles;
        public Lease(ByteBufferPool byteBufferPool, List<ByteBuffer> buffers, List<Boolean> recycles) {
            this.byteBufferPool = byteBufferPool;
            this.buffers = buffers;
            this.recycles = recycles;
        }
        public ByteBuffer acquire(int capacity,boolean direct){
           ByteBuffer buffer=byteBufferPool.acquire(capacity,direct);
           BufferUtil.clearToFill(buffer);
           return  buffer;
        }
        //预先王ByteBuffer list中插入一个ByteBuffer
        public void prepend(ByteBuffer  buffer,boolean recycle){
            insert(0, buffer, recycle);
        }
        public void insert(int index, ByteBuffer buffer, boolean recycle) {
            buffers.add(index,buffer);
            recycles.add(index,recycle);
        }
        public void append(ByteBuffer buffer, boolean recycle) {
            buffers.add(buffer);
            recycles.add(recycle);
        }

        public List<ByteBuffer> getByteBuffers() {
            return buffers;
        }
        //buffer list 所有剩余长度
        public long getTotalLength() {
            long length = 0;
            for (int i = 0; i < buffers.size(); ++i)
                length += buffers.get(i).remaining();
            return length;
        }
        public int getSize() {
            return buffers.size();
        }
        //释放所有可以循环利用的ByteBuffer
        public void recycle() {
            for (int i = 0; i < buffers.size(); ++i)
            {
                ByteBuffer buffer = buffers.get(i);
                if (recycles.get(i))
                    byteBufferPool.release(buffer);
            }
            buffers.clear();
            recycles.clear();
        }
    }
}

具体的ArrayByteBufferPool的实现

public class ArrayByteBufferPool implements ByteBufferPool {
    private final int _min;
    private final Bucket[]_direct;
    private final Bucket[]_indirect;
    private final int _inc;
    public ArrayByteBufferPool()
    {
        this(0,1024,64*1024);
    }

    public ArrayByteBufferPool(int minSize, int increment, int maxSize) {
        //最小size不能大于增量
        if (minSize>=increment)
            throw new IllegalArgumentException("minSize >= increment");
        //最大size 必须是增量的整数倍，并且增量不能大于最大的size
        if ((maxSize%increment)!=0 || increment>=maxSize)
            throw new IllegalArgumentException("increment must be a divisor of maxSize");
        _min=minSize;
        _inc=increment;
        //初始化 maxSize/increment个桶,包含直接内存的与heap的
        _direct=new Bucket[maxSize/increment];
        _indirect=new Bucket[maxSize/increment];

        int size=0;
        for (int i=0;i<_direct.length;i++)
        {
            size+=_inc;
            _direct[i]=new Bucket(size);
            _indirect[i]=new Bucket(size);
        }
    }
    @Override
    public ByteBuffer acquire(int size, boolean direct) {
        //根据size找到对应size的桶
        Bucket bucket = bucketFor(size,direct);
        //如果queue中存在ByteBuffer,则直接返回
        ByteBuffer buffer = bucket==null?null:bucket._queue.poll();
        //初次使用 桶中的queue没有 ByteBuffer
        if (buffer == null){
            //（bucket==null）如果是由于size 超过pool的最大size,造成没有相应的桶
            int capacity = bucket==null?size:bucket._size;
            //分配相应size的ByteBuffer;
            buffer = direct ? BufferUtil.allocateDirect(capacity) : BufferUtil.allocate(capacity);
        }
        return buffer;
    }
    @Override
    public void release(ByteBuffer buffer) {
        if (buffer!=null){
            Bucket bucket = bucketFor(buffer.capacity(),buffer.isDirect());
            if (bucket!=null){
                BufferUtil.clear(buffer);
                //关键：这步是把相应size的ByteBuffer放到相应的size的桶中，byteBuffer入队,用来重用
                bucket._queue.offer(buffer);
            }
        }
    }
    //清空byteBuffer  pool
    public void clear(){
        for (int i=0;i<_direct.length;i++){
            _direct[i]._queue.clear();
            _indirect[i]._queue.clear();
        }
    }
    //根据size寻找 桶
    private Bucket bucketFor(int size,boolean direct) {
        if (size<=_min)
            return null;
        int b=(size-1)/_inc;
        if (b>=_direct.length)
            return null;
        Bucket bucket = direct?_direct[b]:_indirect[b];
        return bucket;
    }
    public static class Bucket{
        public final int _size;
        public final Queue<ByteBuffer> _queue= new ConcurrentLinkedQueue<>();
        Bucket(int size) {
            _size=size;
        }
        @Override
        public String toString()
        {
            return String.format("Bucket@%x{%d,%d}",hashCode(),_size,_queue.size());
        }
    }
}

简单的测试：

public class ByteBufferPoolTest {
    public static void main(String[]args){
        ByteBufferPool.Lease lease =
                new ByteBufferPool.Lease(new ArrayByteBufferPool(),
                                        new ArrayList<>(),
                                        new ArrayList<>());


        ByteBuffer buffer1=lease.acquire(100, false);
        lease.append(buffer1,true);
        buffer1.put("robin yao".getBytes());
        BufferUtil.flipToFlush(buffer1, 0);
        System.out.println(new String(buffer1.array()));
        lease.recycle();
        ByteBuffer buffer2=lease.acquire(100, false);
        //是否是同一个
        System.out.println(buffer1==buffer2);
    }
}

除了ArrayByteBufferPool的实现，还有MappedByteBufferPool的实现，利用ConcurrentMap实现，这里不做介绍

转发请标注来源：http://my.oschina.net/robinyao/blog/403334

END-----------------------------------------

转载于:https://my.oschina.net/robinyao/blog/403334