PooledByteBuf分配及回收之十二Recycler及基内部类初始化

最新推荐文章于 2021-02-03 11:26:56 发布

AnY11

最新推荐文章于 2021-02-03 11:26:56 发布

阅读量245

点赞数

分类专栏： Netty

本文链接：https://blog.csdn.net/AnY11/article/details/113242127

版权

Netty 专栏收录该内容

27 篇文章 5 订阅

订阅专栏

PooledByteBufAllocator初始化

PoolThreadCache初始化

PoolAerna初始化

PoolChunk初始化

PoolSubpage初始化

PooledUnsafeDirectByteBuf初始化

分配微小型PooledByteBuf（未命中缓存场景）

分配小型PooledByteBuf（未命中缓存场景）

分配普通型PooledByteBuf（未命中缓存场景）

PoolChunkList源码解析

ReferenceCountUpdater源码解析

Recycler及基内部类初始化

Recycler.Stack＜T＞压入对象

Recycler.Stack＜T＞弹出对象

PooledByteBuf的回收

Recycler

属性
属性值含义
static final Handle NOOP_HANDLE
new Handle() {
    @Override
    public void recycle(Object object) {
        // NOOP
    }
}
static final AtomicInteger ID_GENERATOR
new AtomicInteger(Integer.MIN_VALUE)
ID生成器
static final int OWN_THREAD_ID
ID_GENERATOR.getAndIncrement()
自己的线程ID
static final int DEFAULT_INITIAL_MAX_CAPACITY_PER_THREAD
4 * 1024
每个线程默认的最大初始容量
static final int DEFAULT_MAX_CAPACITY_PER_THREAD
4 * 1024
每个线程默认的最大容量
static final int INITIAL_CAPACITY
256
初始容量
static final int MAX_SHARED_CAPACITY_FACTOR
2
最大共享容量因子
static final int MAX_DELAYED_QUEUES_PER_THREAD
NettyRuntime.availableProcessors() * 2
每个线程的最大延迟队列数量
static final int LINK_CAPACITY
16
LINK的容量
static final int RATIO
8
final int maxCapacityPerThread
4 * 1024
每个线程的最大容量
final int maxSharedCapacityFactor
2
最大共享容量因子
final int interval
8
默认等于RATIO
final int maxDelayedQueuesPerThread
NettyRuntime.availableProcessors() * 2
每个线程的最大延迟队列数量
final FastThreadLocal<Stack<T>> threadLocal
new FastThreadLocal<Stack<T>>() {
@Override
protected Stack<T> initialValue() {
return new Stack<T>(Recycler.this, Thread.currentThread(), maxCapacityPerThread, maxSharedCapacityFactor,
interval, maxDelayedQueuesPerThread);
}

@Override
protected void onRemoval(Stack<T> value) {
// Let us remove the WeakOrderQueue from the WeakHashMap directly if its safe to remove some overhead
if (value.threadRef.get() == Thread.currentThread()) {
if (DELAYED_RECYCLED.isSet()) {
DELAYED_RECYCLED.get().remove(value);
}
}
}
};
static final FastThreadLocal<Map<Stack<?>, WeakOrderQueue>> DELAYED_RECYCLED
new FastThreadLocal<Map<Stack<?>, WeakOrderQueue>>() {
    @Override
    protected Map<Stack<?>, WeakOrderQueue> initialValue() {
        return new WeakHashMap<Stack<?>, WeakOrderQueue>();
    }
}

属性	值	含义
`static final Handle NOOP_HANDLE`	`new Handle() { @Override public void recycle(Object object) { // NOOP } }`
`static final AtomicInteger ID_GENERATOR`	`new AtomicInteger(Integer.MIN_VALUE)`	ID生成器
`static final int OWN_THREAD_ID`	`ID_GENERATOR.getAndIncrement()`	自己的线程ID
`static final int DEFAULT_INITIAL_MAX_CAPACITY_PER_THREAD`	4 * 1024	每个线程默认的最大初始容量
`static final int DEFAULT_MAX_CAPACITY_PER_THREAD`	4 * 1024	每个线程默认的最大容量
`static final int INITIAL_CAPACITY`	256	初始容量
`static final int MAX_SHARED_CAPACITY_FACTOR`	2	最大共享容量因子
`static final int MAX_DELAYED_QUEUES_PER_THREAD`	`NettyRuntime.availableProcessors() * 2`	每个线程的最大延迟队列数量
`static final int LINK_CAPACITY`	16	LINK的容量
`static final int RATIO`	8
`final int maxCapacityPerThread`	4 * 1024	每个线程的最大容量
`final int maxSharedCapacityFactor`	2	最大共享容量因子
`final int interval`	8	默认等于RATIO
`final int maxDelayedQueuesPerThread`	NettyRuntime.availableProcessors() * 2	每个线程的最大延迟队列数量
`final FastThreadLocal<Stack<T>> threadLocal`	new FastThreadLocal<Stack<T>>() { @Override protected Stack<T> initialValue() { return new Stack<T>(Recycler.this, Thread.currentThread(), maxCapacityPerThread, maxSharedCapacityFactor, interval, maxDelayedQueuesPerThread); } @Override protected void onRemoval(Stack<T> value) { // Let us remove the WeakOrderQueue from the WeakHashMap directly if its safe to remove some overhead if (value.threadRef.get() == Thread.currentThread()) { if (DELAYED_RECYCLED.isSet()) { DELAYED_RECYCLED.get().remove(value); } } } };
`static final FastThreadLocal<Map<Stack<?>, WeakOrderQueue>> DELAYED_RECYCLED`	`new FastThreadLocal<Map<Stack<?>, WeakOrderQueue>>() { @Override protected Map<Stack<?>, WeakOrderQueue> initialValue() { return new WeakHashMap<Stack<?>, WeakOrderQueue>(); } }`

构造方法

    protected Recycler() {
        this(DEFAULT_MAX_CAPACITY_PER_THREAD);
    }

    protected Recycler(int maxCapacityPerThread) {
        this(maxCapacityPerThread, MAX_SHARED_CAPACITY_FACTOR);
    }

    protected Recycler(int maxCapacityPerThread, int maxSharedCapacityFactor) {
        this(maxCapacityPerThread, maxSharedCapacityFactor, RATIO, MAX_DELAYED_QUEUES_PER_THREAD);
    }

    protected Recycler(int maxCapacityPerThread, int maxSharedCapacityFactor,
                       int ratio, int maxDelayedQueuesPerThread) {
        interval = safeFindNextPositivePowerOfTwo(ratio);
        if (maxCapacityPerThread <= 0) {
            this.maxCapacityPerThread = 0;
            this.maxSharedCapacityFactor = 1;
            this.maxDelayedQueuesPerThread = 0;
        } else {
            this.maxCapacityPerThread = maxCapacityPerThread;
            this.maxSharedCapacityFactor = max(1, maxSharedCapacityFactor);
            this.maxDelayedQueuesPerThread = max(0, maxDelayedQueuesPerThread);
        }
    }

DefaultHandle<T>

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

        boolean hasBeenRecycled;

        Stack<?> stack;
        Object value;

        DefaultHandle(Stack<?> stack) {
            this.stack = stack;
        }

    }

Link

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

            int readIndex;
            Link next;
        }

Head

 private static final class Head {

            private final AtomicInteger availableSharedCapacity;

            Link link;

            Head(AtomicInteger availableSharedCapacity) {
                this.availableSharedCapacity = availableSharedCapacity;
            }
}

WeakOrderQueue extends WeakReference<Thread>

属性

static final WeakOrderQueue DUMMY = new WeakOrderQueue();

private final Head head;

private Link tail;
// pointer to another queue of delayed items for the same stack
private WeakOrderQueue next;

private final int id = ID_GENERATOR.getAndIncrement();

private final int interval;

private int handleRecycleCount;

构造方法

        private WeakOrderQueue() {
            super(null);
            head = new Head(null);
            interval = 0;
        }


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

            // 重要的是我们不要将堆栈本身存储在WeakOrderQueue中，因为堆栈也在 WeakHashMap中用作键。因此，只需存储包含的AtomicInteger即可使堆栈本身处于GC状态。
            head = new Head(stack.availableSharedCapacity);
            head.link = tail;
            interval = stack.interval;
            handleRecycleCount = interval; // 从interval开始，因此第一个将被回收。
        }


        static WeakOrderQueue newQueue(Stack<?> stack, Thread thread) {
            // 我们分配了一个链接，所以保留了空间
            if (!Head.reserveSpaceForLink(stack.availableSharedCapacity)) {
                return null;
            }
            final WeakOrderQueue queue = new WeakOrderQueue(stack, thread);
            // 在构造函数外部执行以确保WeakOrderQueue.this不会逸出构造函数，因此//仍可在构造函数时对其进行访问。
            stack.setHead(queue);

            return queue;
        }

            static boolean reserveSpaceForLink(AtomicInteger availableSharedCapacity) {
                for (;;) {
                    int available = availableSharedCapacity.get();
                    //LINK_CAPACITY=16
                    if (available < LINK_CAPACITY) {
                        return false;
                    }
                    if (availableSharedCapacity.compareAndSet(available, available - LINK_CAPACITY)) {
                        return true;
                    }
                }
            }

Stack<T>

属性


final Recycler<T> parent;

final WeakReference<Thread> threadRef;
// 2 * 1024
final AtomicInteger availableSharedCapacity;
// CPU * 2
private final int maxDelayedQueues;
// 4*1024
private final int maxCapacity;
// 初始值为8 当handleRecycleCount<interval的时候,对象会被直接丢弃
private final int interval;
// 256
DefaultHandle<?>[] elements;

int size;
//初始值为8 每回收一个对象handleRecycleCount被重置为0 每丢弃一个对象handleRecycleCount加1
private int handleRecycleCount;

private WeakOrderQueue cursor, prev;

private volatile WeakOrderQueue head;

构造方法

        Stack(Recycler<T> parent, Thread thread, int maxCapacity, int maxSharedCapacityFactor,
              int interval, int maxDelayedQueues) {

            this.parent = parent;

            threadRef = new WeakReference<Thread>(thread);
            //4 * 1024
            this.maxCapacity = maxCapacity;
            //LINK_CAPACITY=16 maxSharedCapacityFactor=2, so availableSharedCapacity = 2 * 1024
            availableSharedCapacity = new AtomicInteger(max(maxCapacity / maxSharedCapacityFactor, LINK_CAPACITY));
            //INITIAL_CAPACITY = 256,so elements的长度为256
            elements = new DefaultHandle[min(INITIAL_CAPACITY, maxCapacity)];
            // interval = 8
            this.interval = interval;
            // handleRecycleCount = 8
            handleRecycleCount = interval; // Start at interval so the first one will be recycled.
            // maxDelayedQueues = CPU*2
            this.maxDelayedQueues = maxDelayedQueues;

        }