Netty Recycler的源码分析

Recycler分析

---

调用来源:PooledByteBuf.java

---

涉及的知识:

• AtomicInteger
• WeakReference
• ThreadLocal

---

在DefaultHandle 中调用的recycle只是把需要回收的对象装在一个栈中,那么问题转化为如何这个栈是如何回收的.

static final class DefaultHandle<T> implements Handle<T> {
        private int lastRecycledId;
        private int recycleId;
        boolean hasBeenRecycled;

        private Stack<?> stack;
        private Object value;

        DefaultHandle(Stack<?> stack) {
            this.stack = stack;
        }
        //其他方法调用的初始入口
        @Override
        public void recycle(Object object) {
            if (object != value) {
                throw new IllegalArgumentException("object does not belong to handle");
            }
            stack.push(this);
        }
    }

那么回收的方法应该和stack有关.

---

在介绍栈之前先了解下WeakOrderQueue,顾名思义,它是弱有序队列.

WeakOrderQueue是由链表实现,其中存储的数据是DefaultHanle类型的数组.值得注意的是虽然类名由弱引用字样,但是属性中并没有弱引用字段.

该类中的所有构造方法都是private类型的,获取实例只能通过newQueue方法获取:

private WeakOrderQueue(Stack<?> stack, Thread thread) {
    head = tail = new Link();
    owner = new WeakReference<Thread>(thread);

    // Its important that we not store the Stack itself in the WeakOrderQueue as the Stack also is used in
    // the WeakHashMap as key. So just store the enclosed AtomicInteger which should allow to have the
    // Stack itself GCed.
    availableSharedCapacity = stack.availableSharedCapacity;
}
static WeakOrderQueue newQueue(Stack<?> stack, Thread thread) {
            WeakOrderQueue queue = new WeakOrderQueue(stack, thread);
            // Done outside of the constructor to ensure WeakOrderQueue.this does not escape the constructor and so
            // may be accessed while its still constructed.
            stack.setHead(queue);
            return queue;
  }

可以看到该方法除了构造并返回WeakOrderQueue实例外还将该实例放入了一个Stack实例中的容器中.

该容器在类中的属性是head,数据结构是用链表实现的栈.(原因)

其中WeakOrderQueue包含一个Link内部类,该内部类继承了AtomicInteger,含有一个存放DefaultHandle类型的数组属性.继承的AtomicInteger用来记录数组的下标.如代码:

private static final class Link extends AtomicInteger {
            private final DefaultHandle<?>[] elements = new DefaultHandle[LINK_CAPACITY];

            private int readIndex;
            private Link next;
        }

其中Link的作用我认为是空间分配与释放的基本单位,当一个Link元素填满时,需要重新生成一个Link实例并将其置入链表末尾.释放的时候在transfer方法中释放.

transfer方法的作用:当Stack没有元素可以提供给消费者时,transfer方法将WeakOrderQueue中的元素传送给该Stack.该行为由Stack主动发起,所以在Stack中才会有一个WeakOrderQueue的链表,Stack在这些链表元素里获取消费者需要的数据.而当一个Link完全被转化后它的引用会被撤销,从而等待被GC

---

Stack之中的存放的元素是DefaultHandle类型的实例,并且存有一个head属性存放WeakOrderQueue.

Stack是外界唯一可访问Recycler类中存储的handle元素.当自身实例不足时,会主动发起transfer方法从WeakOrderQueue中获取.消费者获取元素的代码如下:

//类Recycler
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;
    }

//内部类Stack
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;bei
    ret.lastRecycledId = 0;
    this.size = size;
    return ret;
}

其中:

• 如果stack所代指的池中没有实例,则会new一个Object返回.
• threadLocal解决了线程同步的问题,不过netty并没有使用JDK自带的ThreadLocal,而是自己定义了一个叫FastThreadLocal的类实现的,感兴趣的可以看看源码.
• 每次成功pop一个实例就会将它的recycleId和lastRecycledId置为0,保证下回可再次回收.

注意这行代码的意义

if (ret.lastRecycledId != ret.recycleId) {
    throw new IllegalStateException("recycled multiple times");
}

我认为是这样的:Stack返回给消费者的实例必然是没有其他消费者在使用的实例,也就是说在Stack中的实例都是没有其他消费者使用的.而这两个值什么时候不相等呢,如果一个实例本身在Stack中,已经回收了,在这种状态下再次被回收后就会出现两值不相等的情况.为什么避免这种情况呢,那是因为这样同一个实例的引用会被放在Stack或者WeakOrderQueue的两个位置,当一个消费者拿走一个引用时,另一个引用所指向的实例已经不在符合'没有人使用'这条规则,所以要避免这种情况.

Stack的push方法:pushNow 和 pushLater

void push(DefaultHandle<?> item) {
            Thread currentThread = Thread.currentThread();
            if (threadRef.get() == currentThread) {
                // The current Thread is the thread that belongs to the Stack, we can try to push the object now.
                pushNow(item);
            } else {
                // The current Thread is not the one that belongs to the Stack
                // (or the Thread that belonged to the Stack was collected already), we need to signal that the push
                // happens later.
                pushLater(item, currentThread);
            }
        }

简单地说pushNow是将回收元素放在Stack的元素列表中;pushLater则是放在WeakOrderQueue的元素列表中.

存放在哪取决于Stack中的线程引用是否和当前线程相同.于是这里会看出一个优先级,Stack更趋向于给自己引用线程提供可利用元素.

借用网上一张图总结一下:

• 消费者调用Recyler的get方法,即调用Stack的pop方法获取池中元素
• 如果Stack中元素不足,调用transfer方法,触发scavenge方法,然后从Link中的WeakOrderQueue中获取元素.放到Stack中.
• 调用Handle的recycle方法进行回收,即调用Stack的push方法将回收元素放在相应位置.Recycler中页有recycle方法,但是已经被@Deprecated.