netty源码阅读之性能优化工具类之Recycler获取对象

布满荆棘的人生 2022-05-08 00:34 150阅读 0赞

Recycler获取对象主要分为以下几部分：

1、获取当前线程的Stack

2、从Stack里面弹出对象

3、如果弹出对象为空，那就创建对象并且绑定到Stack里面

我们从Recycler的get方法进入，就是这个源码：

@SuppressWarnings("unchecked")
        public final T get() {
            if (maxCapacityPerThread == 0) {
                return newObject((Handle<T>) NOOP_HANDLE);
            }
            Stack<T> stack = threadLocal.get();
            DefaultHandle<T> handle = stack.pop();
            if (handle == null) {
                handle = stack.newHandle();
                handle.value = newObject(handle);
            }
            return (T) handle.value;
        }

首先看maxCapacityPerThread==0这个分支，看NOOP\_HANDLE这个源码：

@SuppressWarnings("rawtypes")
        private static final Handle NOOP_HANDLE = new Handle() {
            @Override
            public void recycle(Object object) {
                // NOOP
            }
        };

recycle的时候，什么是都不做。

也就是，如果maxCapacityPerThread为0，我们就什么对象都不缓存。

### 一、获取当前线程的Stack ###

就是这段代码：

Stack<T> stack = threadLocal.get();

获取当前线程的stack。

threadLocal就是FastThreadLocal：

private final FastThreadLocal<Stack<T>> threadLocal = new FastThreadLocal<Stack<T>>() {
            @Override
            protected Stack<T> initialValue() {
                return new Stack<T>(Recycler.this, Thread.currentThread(), maxCapacityPerThread, maxSharedCapacityFactor,
                        ratioMask, maxDelayedQueuesPerThread);
            }
        };

初始化的时候，会新建一个stack。

### 二、从Stack里面弹出对象 ###

这个对象就是pop对象。

DefaultHandle<T> handle = stack.pop();

pop出来的对象是一个handle，对象就存在handle里面，也就是要返回的就是handle.value。

然后我们分析pop的过程：

@SuppressWarnings({ "unchecked", "rawtypes" })
            DefaultHandle<T> pop() {
                int size = this.size;
                if (size == 0) {
                    if (!scavenge()) {
                        return null;
                    }
                    size = this.size;
                }
                size --;
                DefaultHandle ret = elements[size];
                elements[size] = null;
                if (ret.lastRecycledId != ret.recycleId) {
                    throw new IllegalStateException("recycled multiple times");
                }
                ret.recycleId = 0;
                ret.lastRecycledId = 0;
                this.size = size;
                return ret;
            }

首先有一个size，这个size就是这个stack里面有多少个对象。如果size等于0，就会调用scavenge()，意思就是如果当前线程没有对象了，但是我的对象有可能在别的线程那里有对象，就去别的线程那里找，后面再分析这个方法。

后续如果size不为0，那就从stack里面取，size--。

DefaultHandle ret = elements\[size\]; elements\[size\] = null;就是把对象取出来并且设置原来的对象为null。

然后：

ret.recycleId = 0;
                ret.lastRecycledId = 0;

这两段代码的意思就是，对象被使用了，并没有在回收次里面。

### 三、创建对象并且绑定到Stack里面 ###

这一段源代码就是我们这里要分析的内容：

if (handle == null) {
                handle = stack.newHandle();
                handle.value = newObject(handle);
            }

handle为空，就在stack里面新建一个handle：

DefaultHandle<T> newHandle() {
                return new DefaultHandle<T>(this);
            }

这个handle是DefaultHandle并且把this传入进去，这个this就是stack：