netty源码分析 - Recycler 对象池的设计

《netty源码分析4 - Recycler对象池的设计》：https://www.jianshu.com/p/854b855bd198
《Netty 对象池实践优化》：https://blog.csdn.net/zhousenshan/article/details/82942381
《Netty轻量级对象池实现分析》：https://www.cnblogs.com/hzmark/p/netty-object-pool.html

一、为什么需要对象池
二、使用姿势
- 2.1 同线程创建回收对象
- 2.2 异线程创建回收对象
三、数据结构
- 3.1 物理数据结构图
- 3.2 逻辑数据结构图（重要）
四、源码分析
- 4.1、Recycler 对象的创建
五、流程总结
六、线程同步问题
七、防止资源泄露的措施

一、为什么需要对象池

减少创建对象时内存分配的消耗，对象的内存分配机制见：https://www.cnblogs.com/java-zhao/p/5180492.html

对象进行重用，不会大量创建对象，减少GC压力

二、使用姿势

private static final Recycler<User> userRecycler = new Recycler<User>() {
    @Override
    protected User newObject(Handle<User> handle) {
        return new User(handle);
    }
};
@Data
static final class User {
    private String name;
    private Recycler.Handle<User> handle;
    public User(Recycler.Handle<User> handle) {
        this.handle = handle;
    }
    public void recycle() {
        handle.recycle(this);
    }
}

首先创建一个对象池 Recycler 对象，重写了其 newObject(Handle handle)方法，当对象池中没有数据时，就调用该方法新建对象，在每一个新建的对象中，都会传入一个 Recycler.Handle对象，用于处理该对象的回收操作。

注意：

一个 T 对象只有一个 Recycler.Handle 对象
一个 Recycler.Handle 对象只属于一个 T 对象

2.1 同线程创建回收对象

@Test
public void testGetAndRecycleAtSameThread() {
    // 1、从回收池获取对象
    User user1 = userRecycler.get();
    // 2、设置对象并使用
    user1.setName("hello,java");
    System.out.println(user1);
    // 3、对象恢复出厂设置
    user1.setName(null);
    // 4、回收对象到对象池
    user1.recycle();
    // 5、从回收池获取对象
    User user2 = userRecycler.get();
    Assert.assertSame(user1, user2);
}

步骤：

main 线程先调用 userRecycler.get()从userRecycler 中获取 User 对象 user1，首次 userRecycler 中没有 User 对象，调用n ewObject 方法进行创建，之后返回；
对 user1 进行赋值并使用
使用结束之后，对 user1 恢复出厂设置（这一步需要使用者自己进行处理，Recycler 不会做）
main 线程将 user1 回收到对象池
main 线程从 userRecycler 中获取 User 对象 user2，这里的 user2 就是之前被回收的 user1 对象。

2.2 异线程创建回收对象

@Test
public void testGetAndRecycleAtDifferentThread() throws InterruptedException {
    // 1、从回收池获取对象
    User user1 = userRecycler.get();
    // 2、设置对象并使用
    user1.setName("hello,java");
    Thread thread = new Thread(()->{
        System.out.println(user1);
        // 3、对象恢复出厂设置
        user1.setName(null);
        // 4、回收对象到对象池
        user1.recycle();
    });
    thread.start();
    thread.join();
    // 5、从回收池获取对象
    User user2 = userRecycler.get();
    Assert.assertSame(user1, user2);
}

步骤：

main 线程先调用 userRecycler.get() 从userRecycler 中获取 User 对象u ser1，首次 userRecycler 中没有User对象，调用 newObject 方法进行创建，之后返回；
对 user1 进行赋值
新线程 thread 使用 user1
使用结束之后，对 user1 恢复出厂设置
thread 线程将 user1 回收到对象池
main 线程从 userRecycler 中获取 User 对象 user2，这里的 user2 就是之前被 thread 线程回收的 user1 对象。

最佳实践：在多个异线程进行 recycle() 方法时，要使用 try-catch，原因见 https://github.com/netty/netty/issues/8220 及其解决方案

三、数据结构

3.1 物理数据结构图

说明：

每一个 Recycler 对象包含一个 FastThreadLocal<Stack> threadLocal 实例；

每一个线程包含一个 Stack 对象，该 Stack 对象包含一个 DefaultHandle[]，而 DefaultHandle 中有一个属性 T value，用于存储真实对象。也就是说，每一个被回收的对象都会被包装成一个 DefaultHandle 对象（而该 DefaultHandle 对象实际上也作为真是对象的一个属性 -- 见“二、使用姿势”）；
Recyler 类包含一个类对象 FastThreadLocal<Map<Stack<?>, WeakOrderQueue>> DELAYED_RECYCLED；

每一个线程对象包含一个 Map<Stack<?>, WeakOrderQueue>，存储着为其他线程创建的 WeakOrderQueue 对象，WeakOrderQueue 对象中存储一个以 Head 为首的 Link 数组，每个 Link 对象中存储一个 DefaultHandle[] 数组，用于存放回收对象。

3.2 逻辑数据结构图（重要）

说明：（假设线程A创建的对象）

线程 A 回收 user1 时，直接将 user1 的 DefaultHandle 对象（内部包含 user1 对象）压入 Stack 的 DefaultHandle[] 中；
线程 B 回收 user1 时，会首先从其 Map<Stack<?>, WeakOrderQueue> 对象中获取 key=线程A的Stack 对象的 WeakOrderQueue，然后直接将 user1 的 DefaultHandle 对象（内部包含user1对象）压入该 WeakOrderQueue 中的 Link 链表中的尾部 Link 的 DefaultHandle[]中，同时，这个 WeakOrderQueue 会与线程 A 的 Stack 中的 head 属性进行关联，用于后续对象的 pop 操作；
当线程 A 从对象池获取对象时，如果线程 A 的 Stack 中有对象，则直接弹出；如果没有对象，则先从其 head 属性所指向的 WeakorderQueue 开始遍历 queue 链表，将 User 对象从其他线程的 WeakOrderQueue 中转移到线程 A 的 Stack 中（一次 pop 操作只转移一个包含了元素的 Link），再弹出。

注意：（假设线程A创建的对象）

Stack 中存储的是线程 A 回收的对象，以及从线程 X 的 WeakOrderQueue 中转移过来的对象。
WeakOrderQueue 中存储的是线程 X 回收的线程 A 创建的对象。

四、源码分析

4.1、Recycler 对象的创建

/**
 * 唯一ID生成器，用在两处：
 * 1、当前线程ID
 * 2、WeakOrderQueue的id
 */
private static final AtomicInteger ID_GENERATOR = new AtomicInteger(Integer.MIN_VALUE);
/**
 * static变量, 生成并获取一个唯一id.
 * 用于pushNow()中的item.recycleId和item.lastRecycleId的设定
 */
private static final int OWN_THREAD_ID = ID_GENERATOR.getAndIncrement();
/**
 * 表示一个不需要回收的包装对象，用于在禁止使用Recycler功能时进行占位的功能
 * 仅当io.netty.recycler.maxCapacityPerThread<=0时用到
 */
private static final Handle NOOP_HANDLE = new Handle() {
    @Override
    public void recycle(Object object) {
        // NOOP
    }
};
/**
 * 每个Stack默认的最大容量
 * 注意：
 * 1、当io.netty.recycler.maxCapacityPerThread<=0时，禁用回收功能（在netty中，只有=0可以禁用，<0默认使用4k）
 * 2、Recycler中有且只有两个地方存储DefaultHandle对象（Stack和Link），
 * 最多可存储MAX_CAPACITY_PER_THREAD + 最大可共享容量 = 4k + 4k/2 = 6k
 *
 * 实际上，在netty中，Recycler提供了两种设置属性的方式
 * 第一种：-Dio.netty.recycler.ratio等jvm启动参数方式
 * 第二种：Recycler(int maxCapacityPerThread)构造器传入方式
 */
private static final int MAX_CAPACITY_PER_THREAD = Math.max(Integer.parseInt(System.getProperty("io.netty.recycler.maxCapacityPerThread", String.valueOf(4 * 1024))), 0);
/**
 * 每个Stack默认的初始容量，默认为256
 * 后续根据需要进行扩容，直到<=MAX_CAPACITY_PER_THREAD
 */
private static final int INITIAL_CAPACITY = Math.min(256, MAX_CAPACITY_PER_THREAD);
/**
 * 最大可共享的容量因子。
 * 最大可共享的容量 = maxCapacity / maxSharedCapacityFactor，maxSharedCapacityFactor默认为2
 */
private static final int MAX_SHARED_CAPACITY_FACTOR = Math.max(2, Integer.valueOf(System.getProperty("io.netty.recycler.maxSharedCapacityFactor", String.valueOf(2))));
/**
 * 每个线程可拥有多少个WeakOrderQueue，默认为2*cpu核数
 * 实际上就是当前线程的Map<Stack<?>, WeakOrderQueue>的size最大值
 */
private static final int MAX_DELAYE_DQUEUES_PERTHREAD = Math.max(0, Integer.parseInt(System.getProperty("io.netty.recycler.maxDelayedQueuesPerThread", String.valueOf(2 * Runtime.getRuntime().availableProcessors()))));
/**
 * WeakOrderQueue中的Link中的数组DefaultHandle<?>[] elements容量，默认为16，
 * 当一个Link中的DefaultHandle元素达到16个时，会新创建一个Link进行存储，这些Link组成链表，当然
 * 所有的Link加起来的容量要<=最大可共享容量。
 */
private static final int LINK_CAPACITY = MathUtil.safeFindNextPositivePowerOfTwo(Integer.parseInt(System.getProperty("io.netty.recycler.linkCapacity", String.valueOf(16))));
/**
 * 回收因子，默认为8。
 * 即默认每8个对象，允许回收一次，直接扔掉7个，可以让recycler的容量缓慢的增大，避免爆发式的请求
 */
private static final int RATIO = MathUtil.safeFindNextPositivePowerOfTwo(Integer.parseInt(System.getProperty("io.netty.recycler.ratio", String.valueOf(8))));
/**
 * 1、每个Recycler类（而不是每一个Recycler对象）都有一个DELAYED_RECYCLED
 * 原因：可以根据一个Stack<T>对象唯一的找到一个WeakOrderQueue对象，所以此处不需要每个对象建立一个DELAYED_RECYCLED
 * 2、由于DELAYED_RECYCLED是一个类变量，所以需要包容多个T，此处泛型需要使用?
 * 3、WeakHashMap：当Stack没有强引用可达时，整个Entry{Stack<?>, WeakOrderQueue}都会加入相应的弱引用队列等待回收
 */
private static final FastThreadLocal<Map<Stack<?>, WeakOrderQueue>> DELAYED_RECYCLED = new FastThreadLocal<Map<Stack<?>, WeakOrderQueue>>() {
    @Override
    protected Map<Stack<?>, WeakOrderQueue> initialValue() throws Exception {
        return new WeakHashMap<>();
    }
};
/**
 * 1、每个Recycler对象都有一个threadLocal
 * 原因：因为一个Stack要指明存储的对象泛型T，而不同的Recycler<T>对象的T可能不同，所以此处的FastThreadLocal是对象级别
 * 2、每条线程都有一个Stack<T>对象
 */
private final FastThreadLocal<Stack<T>> threadLocal = new FastThreadLocal<Stack<T>>() {
    @Override
    protected Stack<T> initialValue() throws Exception {
        return new Stack<>(Thread.currentThread(), MAX_CAPACITY_PER_THREAD, MAX_DELAYE_DQUEUES_PERTHREAD, MAX_SHARED_CAPACITY_FACTOR, MathUtil.safeFindNextPositivePowerOfTwo(RATIO) - 1);
    }
    @Override
    protected void onRemoved(Stack<T> stack) throws Exception {
        // Let us remove the WeakOrderQueue from the WeakHashMap directly if its safe to remove some overhead
        if (stack.threadRef.get() == Thread.currentThread() && DELAYED_RECYCLED.isSet()) {
            DELAYED_RECYCLED.get().remove(stack);
        }
    }
};
/**
 * 创建一个对象
 * 1、由子类进行复写，所以使用protected修饰
 * 2、传入Handle对象，对创建出来的对象进行回收操作
 */
protected abstract T newObject(Handle<T> handle);
/**
 * 提供对象的回收功能，由子类进行复写
 * 目前该接口只有两个实现：NOOP_HANDLE和DefaultHandle
 */
public interface Handle<T> {
    void recycle(T object);
}

注意：

在 netty 中，实际上提供了两种设置参数的方式，一种是通过 -Dio.netty.recycler.ratio 等 jvm 启动参数方式，另外一种就是提供了几个 Recycler 的构造函数，通过 Recycler(int maxCapacityPerThread) 构造器传入方式。

4.2、同线程获取对象

获取对象的操作起点是在 Recycler#get()：

/**
 * 获取对象
 */
public final T get() {
    /**
     * 0、如果maxCapacityPerThread == 0，禁止回收功能
     * 创建一个对象，其Recycler.Handle<User> handle属性为NOOP_HANDLE，
     * 该对象的recycle(Object object)不做任何事情，即不做回收
     */
    if (MAX_CAPACITY_PER_THREAD == 0) {
        return newObject((Handle<T>) NOOP_HANDLE);
    }
    /**
     * 1、获取当前线程的Stack<T>对象
     */
    Stack<T> stack = threadLocal.get();
    /**
     * 2、从Stack<T>对象中获取DefaultHandle<T>
     */
    DefaultHandle<T> handle = stack.pop();
    if (handle == null) {
        /**
         * 3、 新建一个DefaultHandle对象 -> 然后新建T对象 -> 存储到DefaultHandle对象
         * 此处会发现一个DefaultHandle对象对应一个Object对象，二者相互包含。
         */
        handle = stack.newHandle();
        handle.value = newObject(handle);
    }
    /**
     * 4、返回value
     */
    return handle.value;
}

当首次执行 threadLocal.get() 时，会调用 threadLocal#initialValue() 来创建一个 Stack 对象。

/**
 * 该Stack所属的线程
 * why WeakReference?
 * 假设该线程对象在外界已经没有强引用了，那么实际上该线程对象就可以被回收了。
 * 但是如果此处用的是强引用，那么虽然外界不再对该线程有强引用，但是该stack对象还持有强引用
 * （假设用户存储了DefaultHandle对象，然后一直不释放，而DefaultHandle对象又持有stack引用），导致该线程对象无法释放。
 *
 * from netty:
 * The biggest issue is if we do not use a WeakReference the Thread may not be able to be collected at all
 * if the user will store a reference to the DefaultHandle somewhere and never clear this reference (or not clear it in a timely manner)
 */
private WeakReference<Thread> threadRef;
/**
 * Stack底层数据结构，真正的用来存储数据
 */
private DefaultHandle<T>[] elements;
/**
 * elements中的元素个数，同时也可作为操作数组的下标
 * 数组只有elements.length来计算数组容量的函数，没有计算当前数组中的元素个数的函数，所以需要我们去记录，不然需要每次都去计算
 */
private int size;
/**
 * elements最大的容量：默认最大为4k，4096
 */
private int maxCapacity;
/**
 * 可用的共享内存大小，默认为maxCapacity/maxSharedCapacityFactor = 4k/2 = 2k = 2048
 * 假设当前的Stack是线程A的，则其他线程B~X等去回收线程A创建的对象时，可回收最多A创建的多少个对象
 * 注意：那么实际上线程A创建的对象最终最多可以被回收maxCapacity + availableSharedCapacity个，默认为6k个
 *
 * why AtomicInteger?
 * 当线程B和线程C同时创建线程A的WeakOrderQueue的时候，会同时分配内存，需要同时操作availableSharedCapacity
 * 具体见：WeakOrderQueue.allocate
 */
private AtomicInteger availableSharedCapacity;
/**
 * DELAYED_RECYCLED中最多可存储的{Stack，WeakOrderQueue}键值对个数
 */
private int maxDelayedQueues;
/**
 * 默认为8-1=7，即2^3-1，控制每8个元素只有一个可以被recycle，其余7个被扔掉
 */
private int ratioMask;
public Stack(Thread threadRef,
             int maxCapacity,
             int maxDelayedQueues,
             int maxSharedCapacityFactor,
             int ratioMask) {
    this.elements = new DefaultHandle[Math.min(maxCapacity, INITIAL_CAPACITY)];
    this.threadRef = new WeakReference<>(threadRef);
    this.maxCapacity = maxCapacity;
    this.maxDelayedQueues = maxDelayedQueues;
    this.availableSharedCapacity = new AtomicInteger(Math.max(maxCapacity / maxSharedCapacityFactor, LINK_CAPACITY));
    this.ratioMask = ratioMask;
}

创建好一个 Stack 对象之后，就会调用 stack.pop() 进行对象的获取。

DefaultHandle<T> pop() {
    int size = this.size;   // 将对象变量赋值给方法内变量，避免频繁从主内存中读取size变量吗??
    // 1. size=0 则说明本线程的Stack没有可用的对象，先从其它线程中获取。
    //    由于在transfer(Stack<?> dst)的过程中，可能将其他线程的WeakOrderQueue中的DefaultHandle对象
    //    传递到当前的Stack，所以size发生了变化，需要重新赋值
    if (size == 0) {
        if (!scavenge()) {
            return null;
        }
        size = this.size;
    }
    // 2. 注意：因为一个Recycler<T>只能回收一种类型T的对象，所以element可以直接使用操作size来作为下标来进行获取
    //    同时清空ret在Stack队列中的资源
    size --;
    DefaultHandle ret = elements[size];
    elements[size] = null;
    if (ret.lastRecycledId != ret.recycleId) {
        throw new IllegalStateException("recycled multiple times");
    }
    ret.recycleId = ret.lastRecycledId = 0;
    this.size = size;
    return ret;
}

获取对象的逻辑也比较简单，当 Stack 中的 DefaultHandle[] 的 size 为 0 时，需要从其他线程的 WeakOrderQueue 中转移数据到 Stack 中的 DefaultHandle[]，即 scavenge() 方法，该转移方式在 4.5 中再聊。当 Stack 中的 DefaultHandle[] 中最终有了数据时，直接获取最后一个元素，并进行一些防护性检查和元素的设置等。

假设最终确实无法从对象池中获取到对象，则会首先创建一个 DefaultHandle 对象，之后调用 Recycler 的子类重写的 newObject 方法进行 DefaultHandle 对象和真实对象 user1 的绑定，最后返回 user1。

/***************************Stack****************************/
DefaultHandle<T> newHandle() {
    return new DefaultHandle<>(this);
}
/**********************DefaultHandle**********************/
static final class DefaultHandle<T> implements Handle<T> {
    /**
     * 真正的对象，value与Handle一一对应
     */
    private T value;
    /**
     * 标记是否已经被回收：
     * 该值仅仅用于控制是否执行 (++handleRecycleCount & ratioMask) != 0 这段逻辑，而不会用于阻止重复回收的操作，
     * 重复回收的操作由item.recycleId | item.lastRecycledId来阻止
     */
    private boolean hasBeenRecycled;
    /**
     * 只有在pushNow()中会设置值OWN_THREAD_ID
     * 在poll()中置位0
     */
    private int recycledId;
    /**
     * pushNow() = OWN_THREAD_ID
     * 在pushLater中的add(DefaultHandle handle)操作中 == id（当前的WeakOrderQueue的唯一ID）
     * 在poll()中置位0
     */
    private int lastRecycledId;
    /**
     * 当前的DefaultHandle对象所属的Stack
     */
    private Stack<T> stack;
    DefaultHandle(Stack<T> stack) {
        this.stack = stack;
    }
    @Override
    public void recycle(T object) {
        // 防护性判断
        if (object != value) {
            throw new IllegalArgumentException("object does not belong to handle");
        }
        Stack<T> stack = this.stack;
        if (lastRecycledId != recycledId || stack == null) {
            throw new IllegalStateException("recycled already");
        }
        /**
         * 回收对象，this指的是当前的DefaultHandle对象
         */
        stack.push(this);
    }
}

Recycler#get 总体步骤：

如果 maxCapacityPerThread == 0，则禁用回收功能：新建 User 对象，将一个什么都不做的 NOOP_HANDLE 塞入 User 对象，进而不做回收操作；否则
获取当前线程的 Stack对象，如果没有，则新建一个 Stack 对象，在 Stack 对象的构造器中，会新建一个 DefaultHandle[]，默认大小为 4k；
从 stack 对象中 pop 出一个 DefaultHandle 来，如果不为 null，直接返回 DefaultHandle 存储的真实对象 value；如果为 null，则新建一个 DefaultHandle 对象，之后新建 User 对象，并进行 DefaultHandle 对象和 User 对象的绑定，最终返回 user 对象。

Stack#pop的步骤：

首先获取当前的 Stack 中的 DefaultHandle 对象中的元素个数。
如果不为 0，直接获取 Stack 对象中 DefaultHandle[] 的最后一位元素，然后将该元素置为 null，之后做防护性检测，最后重置当前的 stack 对象的 size 属性以及获取到的 DefaultHandle 对象的 recycledId 和 lastRecycledId 回收标记，返回 DefaultHandle 对象。
如果为 0，则从其他线程的与当前的 Stack 对象关联的 WeakOrderQueue 中获取元素，并转移到 Stack 的 DefaultHandle[] 中（每一次 pop 只转移一个 Link），如果转移不成功，说明没有元素可用，直接返回 null；如果转移成功，则重置 size 属性为转移后的 Stack 的 DefaultHandle[] 的 size，之后按照第二步执行。

4.3 同线程回收对象

/***********************DefaultHandle************************/
@Override
public void recycle(T object) {
    // 防护性判断
    if (object != value) {
        throw new IllegalArgumentException("object does not belong to handle");
    }
    // https://github.com/netty/netty/issues/8220
    if (this.lastRecycledId != this.recycledId) {
        throw new IllegalStateException("recycled already");
    }
    /**
     * 回收对象，this指的是当前的DefaultHandle对象
     */
    stack.push(this);
}
/***********************Stack************************/
/**
 * 每有一个元素将要被回收, 则该值+1，例如第一个被回收的元素的handleRecycleCount=handleRecycleCount+1=0
 * 与ratioMask配合，用来决定当前的元素是被回收还是被drop。
 * 例如 ++handleRecycleCount & ratioMask（7），其实相当于 ++handleRecycleCount % 8，
 * 则当 ++handleRecycleCount = 0/8/16/...时，元素被回收，其余的元素直接被drop
 */
private int handleRecycleCount = -1;
void push(DefaultHandle<T> item) {
    Thread currentThread = Thread.currentThread();
    if (threadRef.get() == currentThread) {
        pushNow(item);
    } else {
        pushLater(item, currentThread);
    }
}
/**
 * 立刻将item元素压入Stack中
 */
private void pushNow(DefaultHandle<T> item) {
    // (item.recycleId | item.lastRecycleId) != 0 等价于 item.recycleId!=0 && item.lastRecycleId!=0
    // 当item开始创建时item.recycleId==0 && item.lastRecycleId==0
    // 当item被recycle时，item.recycleId==x，item.lastRecycleId==y 进行赋值
    // 当item被poll之后， item.recycleId = item.lastRecycleId = 0
    // 所以当item.recycleId 和 item.lastRecycleId 任何一个不为0，则表示回收过
    if ((item.recycledId | item.lastRecycledId) != 0) {
        throw new IllegalStateException("recycled already");
    }
    item.recycledId = item.lastRecycledId = OWN_THREAD_ID;
    int size = this.size;
    if (size >= maxCapacity || dropHandle(item)) {
        return;
    }
    // stack中的elements扩容两倍，复制元素，将新数组赋值给stack.elements
    if (size == elements.length) {
        elements = Arrays.copyOf(elements, Math.min(size << 1, maxCapacity));
    }
    // 放置元素
    elements[size] = item;
    this.size = size + 1;
}
/**
 * 两个drop的时机
 * 1、pushNow：当前线程将数据push到Stack中
 * 2、transfer：将其他线程的WeakOrderQueue中的数据转移到当前的Stack中
 */
private boolean dropHandle(DefaultHandle<T> item) {
    if (!item.hasBeenRecycled) {
        // 每8个对象：扔掉7个，回收一个
        // 回收的索引：handleRecycleCount - 0/8/16/24/32/...
        if ((++handleRecycleCount & ratioMask) != 0) {
            return true;
        }
        // 设置已经被回收了的标志，实际上此处还没有被回收，在pushNow(DefaultHandle<T> item)接下来的逻辑就会进行回收
        // 对于pushNow(DefaultHandle<T> item)：该值仅仅用于控制是否执行 (++handleRecycleCount & ratioMask) != 0 这段逻辑，而不会用于阻止重复回收的操作，重复回收的操作由item.recycleId | item.lastRecycledId来阻止
        item.hasBeenRecycled = true;
    }
    return false;
}

DefaultHandle#recycle 步骤：

首先 Recycler 对象做防护性检测，并且做多次回收的检测（netty-4.1.28 是没有这个检测的，笔者提了一个 bug 给 netty）；

之后向 stack 对象中 push 当前的 DefaultHandle 对象
stack 先检测当前的线程是否是创建 stack 的线程，如果不是，则走异线程回收逻辑；如果是，则首先判断是否重复回收，然后判断 stack 的 DefaultHandle[] 中的元素个数是否已经超过最大容量（4k），如果是，直接返回；如果不是，则计算当前元素是否需要回收（netty 为了防止 Stack 的 DefaultHandle[] 数组发生爆炸性的增长，所以默认采取每 8 个元素回收一个，扔掉 7 个的策略），如果不需要回收，直接返回；如果需要回收，则
判断当前的 DefaultHandle[] 是否还有空位，如果没有，以 maxCapacity 为最大边界扩容 2 倍，之后拷贝旧数组的元素到新数组，然后将当前的 DefaultHandle 对象放置到 DefaultHandle[] 中
最后重置 stack.size 属性

4.4 异线程回收对象

/***********************Stack************************/
/**
 * 该值是当线程B回收线程A创建的对象时，线程B会为线程A的Stack对象创建一个WeakOrderQueue对象，
 * 该WeakOrderQueue指向这里的head，用于后续线程A对对象的查找操作
 * Q: why volatile?
 * A: 假设线程A正要读取对象X，此时需要从其他线程的WeakOrderQueue中读取，假设此时线程B正好创建Queue，并向Queue中放入一个对象X；假设恰好次Queue就是线程A的Stack的head
 * 使用volatile可以立即读取到该queue。
 *
 * 对于head的设置，具有同步问题。具体见此处的volatile和synchronized void setHead(WeakOrderQueue queue)
 */
private volatile WeakOrderQueue head;
/**
 * 先将item元素加入WeakOrderQueue，后续再从WeakOrderQueue中将元素压入Stack中
 */
private void pushLater(DefaultHandle<T> item, Thread currentThread) {
    Map<Stack<?>, WeakOrderQueue> delayedRecycled = DELAYED_RECYCLED.get();
    WeakOrderQueue queue = delayedRecycled.get(this);
    if (queue == null) {
        // 如果DELAYED_RECYCLED中的key-value对已经达到了maxDelayedQueues，则后续的无法回收 - 内存保护
        if (delayedRecycled.size() >= maxDelayedQueues) {
            delayedRecycled.put(this, WeakOrderQueue.DUMMY);
            return;
        }
        if ((queue = WeakOrderQueue.allocate(this, currentThread)) == null) {
            // drop object
            return;
        }
        delayedRecycled.put(this, queue);
    } else if (queue == WeakOrderQueue.DUMMY) {
        // drop object
        return;
    }
    queue.add(item);
}
/**
 * 假设线程B和线程C同时回收线程A的对象时，有可能会同时newQueue，就可能同时setHead，所以这里需要加锁
 * 以head==null的时候为例，
 * 加锁：
 * 线程B先执行，则head = 线程B的queue；之后线程C执行，此时将当前的head也就是线程B的queue作为线程C的queue的next，组成链表，之后设置head为线程C的queue
 * 不加锁：
 * 线程B先执行queue.setNext(head);此时线程B的queue.next=null->线程C执行queue.setNext(head);线程C的queue.next=null
 * -> 线程B执行head = queue;设置head为线程B的queue -> 线程C执行head = queue;设置head为线程C的queue
 *
 * 注意：此时线程B和线程C的queue没有连起来，则之后的poll()就不会从B进行查询。（B就是资源泄露）
 */
synchronized void setHead(WeakOrderQueue queue) {
    queue.setNext(head);
    head = queue;
}
/***********************WeakOrderQueue************************/
/**
 * 如果DELAYED_RECYCLED中的key-value对已经达到了maxDelayedQueues，
 * 对于后续的Stack，其对应的WeakOrderQueue设置为DUMMY，
 * 后续如果检测到DELAYED_RECYCLED中对应的Stack的value是WeakOrderQueue.DUMMY时，直接返回，不做存储操作
 */
static final WeakOrderQueue DUMMY = new WeakOrderQueue();
/**
 * WeakOrderQueue的唯一标记
 */
private final int id = ID_GENERATOR.incrementAndGet();
private final Head head;
private Link tail;
/**
 * pointer to another queue of delayed items for the same stack
 */
private WeakOrderQueue next;
/**
 * 1、why WeakReference？与Stack相同。
 * 2、作用是在poll的时候，如果owner不存在了，则需要将该线程所包含的WeakOrderQueue的元素释放，然后从链表中删除该Queue。
 */
private final WeakReference<Thread> owner;
private <T> WeakOrderQueue(Stack<T> stack, Thread currentThread) {
    // 创建有效Link节点，恰好是尾节点
    tail = new Link();
    // 创建Link链表头节点，只是占位符
    head = new Head(stack.availableSharedCapacity);
    head.link = tail;
    owner = new WeakReference<>(currentThread);
}
private WeakOrderQueue() {
    owner = null;
    head = new Head(null);
}
private static <T> WeakOrderQueue allocate(Stack<T> stack, Thread currentThread) {
    return Head.reserveSpace(stack.availableSharedCapacity, LINK_CAPACITY) ? newQueue(stack, currentThread) : null;
}
private static <T> WeakOrderQueue newQueue(Stack<T> stack, Thread currentThread) {
    // 创建WeakOrderQueue
    WeakOrderQueue queue = new WeakOrderQueue(stack, currentThread);
    // 将该queue赋值给stack的head属性
    stack.setHead(queue);
    /**
     * 将新建的queue添加到Cleaner中，当queue不可达时，
     * 调用head中的run()方法回收内存availableSharedCapacity，否则该值将不会增加，影响后续的Link的创建
     */
    return queue;
}
private void setNext(WeakOrderQueue next) {
    assert next != this;
    this.next = next;
}
private <T> void add(DefaultHandle<T> item) {
    item.lastRecycledId = id;
    Link tail = this.tail;
    int writeIndex;
    // 判断一个Link对象是否已经满了：
    // 如果没满，直接添加；
    // 如果已经满了，创建一个新的Link对象，之后重组Link链表，然后添加元素的末尾的Link（除了这个Link，前边的Link全部已经满了）
    if ((writeIndex = tail.get()) == LINK_CAPACITY) {
        if (!head.reserveSpace(LINK_CAPACITY)) {
            // drop item
            return;
        }
        /**
         * 此处创建一个Link，会将该Link作为新的tail-Link，之前的tail-Link已经满了，成为正常的Link了。重组Link链表
         * 之前是HEAD -> tail-Link，重组后HEAD -> 之前的tail-Link -> 新的tail-Link
         */
        tail = this.tail = tail.next = new Link();
        writeIndex = tail.get(); // 0
    }
    tail.elements[writeIndex] = item;
    /**
     * 如果使用者在将DefaultHandle对象压入队列后，
     * 将Stack设置为null，但是此处的DefaultHandle是持有stack的强引用的，则Stack对象无法回收；
     * 而且由于此处DefaultHandle是持有stack的强引用，WeakHashMap中对应stack的WeakOrderQueue也无法被回收掉了，导致内存泄漏。
     */
    item.stack = null;
    // we lazy set to ensure that setting stack to null appears before we unnull it in the owning thread;
    // this also means we guarantee visibility of an element in the queue if we see the index updated
    // tail本身继承于AtomicInteger，所以此处直接对tail进行+1操作
    // why lazySet? https://github.com/netty/netty/issues/8215
    tail.lazySet(writeIndex + 1);
//            tail.set(writeIndex + 1);
}
/***********************WeakOrderQueue.Head************************/
// Head仅仅作为head-Link的占位符，仅用于ObjectCleaner回收操作
static final class Head {
    private final AtomicInteger availableSharedCapacity;
    /**
     * 指定读操作的Link节点，
     * eg. Head -> Link1 -> Link2
     * 假设此时的读操作在Link2上进行时，则此处的link == Link2，见transfer(Stack dst),
     * 实际上此时Link1已经被读完了，Link1变成了垃圾（一旦一个Link的读指针指向了最后，则该Link不会被重复利用，而是被GC掉，
     * 之后回收空间，新建Link再进行操作）
     */
    private Link link;
    private Head(AtomicInteger availableSharedCapacity) {
        this.availableSharedCapacity = availableSharedCapacity;
    }
    /**
     * 这里可以理解为一次内存的批量分配，每次从availableSharedCapacity中分配space个大小的内存。
     * 如果一个Link中不是放置一个DefaultHandle[]，而是只放置一个DefaultHandle，那么此处的space==1，这样的话就需要频繁的进行内存分配
     */
    private boolean reserveSpace(int space) {
        return reserveSpace(availableSharedCapacity, space);
    }
    private static boolean reserveSpace(AtomicInteger availableSharedCapacity, int space) {
        assert space > 0;
        // cas + 无限重试进行 分配
        for (; ; ) {
            int available = availableSharedCapacity.get();
            if (available < space) {
                return false;
            }
            // 注意：这里使用的是AtomicInteger，当这里的availableSharedCapacity发生变化时，实际上就是改变的stack.availableSharedCapacity的int value属性的值
            if (availableSharedCapacity.compareAndSet(available, available - space)) {
                return true;
            }
        }
    }
    private void reclaimSpace(int space) {
        assert space >= 0;
        availableSharedCapacity.addAndGet(space);
    }
    /**
     * 在该对象被真正的回收前，执行该方法
     * 循环释放当前的WeakOrderQueue中的Link链表所占用的所有共享空间availableSharedCapacity，
     * 如果不释放，否则该值将不会增加，影响后续的Link的创建
     */
    @Override
    protected void finalize() throws Throwable {
        try {
            super.finalize();
        } finally {
            Link head = link;
            // Unlink to help GC
            link = null;
            while (head != null) {
                reclaimSpace(LINK_CAPACITY);
                Link next = head.next;
                // Unlink to help GC and guard against GC nepotism.
                head.next = null;
                head = next;
            }
        }
    }
}
/***********************WeakOrderQueue.Link************************/
static final class Link extends AtomicInteger {
    private final DefaultHandle<?>[] elements = new DefaultHandle[LINK_CAPACITY];
    /**
     * Link的下一个节点
     */
    private Link next;
    public int readIndex;
}

Stack#pushLater 步骤：

首先获取当前线程的 Map<Stack<?>, WeakOrderQueue> 对象，如果没有就创建一个空 map；
然后从 map 对象中获取 key 为当前的 Stack 对象的 WeakOrderQueue；
如果存在，则判断该 queue 是不是 WeakOrderQueue.DUMMY 对象，如果是，直接返回，不回收对象；如果不是则调用 WeakOrderQueue#add(DefaultHandle item) 添加对象；
如果不存在，则先判断当前的 map 的数量是不是已经达到或者超过 maxDelayedQueues 限制了（默认最大为 2 * cpu 核数个），如果是，则直接塞入一个{当前的 Stack 对象, WeakOrderQueue.DUMMY 对象}，最后扔掉当前的 DefaultHandle 对象；如果不是，则会新建 WeakOrderQueue，之后将{当前的 Stack 对象, 创建好的 WeakOrderQueue 对象}添加到map中，最后调用 WeakOrderQueue#add(DefaultHandle item) 添加对象。

WeakOrderQueue 的创建流程：

首先判断当前的 Stack 对象的可用共享内存（初始默认值为 2k）是否还有足够的空间（LINK_CAPACITY，默认为16）来存放一个 Link，如果不够了，直接返回；否则，使用 cas+ 无限重试的方式设置 Stack 的可用共享内存 = 当前的可用共享内存大小 - 16，也就是分配一个 Link 大小的空间；
如果分配成功，则会新建一个 WeakOrderQueue 对象：在 WeakOrderQueue 构造器中，首先创建一个 Link 对象，而每一个 Link 对象内部都包含一个 DefaultHandle[LINK_CAPACITY]，用于存放回收的对象；然后创建一个 Head 对象，之后将 Head.link 设置为刚刚创建出来的 Link 对象，用于后续的对象 pop 操作；最后设置当前的 WeakOrderQueue 所属的线程为当前线程。
先将原本的 stack.head 赋值给刚刚创建的 WeakOrderQueue 的 next 节点，之后将刚刚创建的 WeakOrderQueue 设置为 stack.head（这一步非常重要：假设线程 A 创建对象，此处是线程 C 回收对象，则线程 C 先获取其 Map<Stack<?>, WeakOrderQueue> 对象中 key=线程A的stack对象的 WeakOrderQueue，然后将该 Queue 赋值给线程 A 的 stack.head，后续的 pop 操作打基础），形成 WeakOrderQueue 的链表结构。

WeakOrderQueue#add(DefaultHandle item)添加对象流程：

首先设置 item.lastRecycledId = 当前 WeakOrderQueue 的 id
然后看当前的 WeakOrderQueue 中的 Link 节点链表中的尾部 Link 节点的 DefaultHandle[] 中的元素个数是否已经达到 LINK_CAPACITY（16）
如果不是，则直接将当前的 DefaultHandle 元素插入尾部 Link 节点的 DefaultHandle[] 中，之后置空当前的 DefaultHandle 元素的 stack 属性，最后记录当前的 DefaultHandle[] 中的元素数量；
如果是，则先从当前的可共享容量中划分一块新的 Link 容量，如果不够划分，直接返回；如果够，则新建一个 Link，并且放在当前的 Link 链表中的尾部节点处，与之前的 tail 节点连起来（链表），之后进行第三步的操作。

4.5 从异线程获取对象

/***********************Stack************************/
/**
 * cursor：当前操作的WeakOrderQueue
 * prev：cursor的前一个WeakOrderQueue
 */
private WeakOrderQueue cursor, prev;
DefaultHandle<T> pop() {
    int size = this.size;
    if (size == 0) {
        if (!scavenge()) {
            return null;
        }
        /**
         * 由于在transfer(Stack<?> dst)的过程中，可能会将其他线程的WeakOrderQueue中的DefaultHandle对象传递到当前的Stack,
         * 所以size发生了变化，需要重新赋值
         */
        size = this.size;
    }
    /**
     * 注意：因为一个Recycler<T>只能回收一种类型T的对象，所以element可以直接使用操作size来作为下标来进行获取
     */
    size--;
    DefaultHandle<T> ret = elements[size];
    // 置空
    elements[size] = null;
    if (ret.lastRecycledId != ret.recycledId) {
        throw new IllegalStateException("recycled multiple times");
    }
    this.size = size;
    // 置位
    ret.recycledId = ret.lastRecycledId = 0;
    return ret;
}
private boolean scavenge() {
    if (scavengeSome()) {
        return true;
    }
    // reset our scavenge cursor
    prev = null;
    cursor = head;
    return false;
}
private boolean scavengeSome() {
    WeakOrderQueue prev;
    WeakOrderQueue cursor = this.cursor;
    if (cursor == null) {
        prev = null;
        cursor = head;
        // 如果head==null，表示当前的Stack对象没有WeakOrderQueue，直接返回
        if (cursor == null) {
            return false;
        }
    } else {
        prev = this.prev;
    }
    boolean success = false;
    do {
        if (cursor.transfer(this)) {
            success = true;
            break;
        }
        // 遍历下一个WeakOrderQueue
        WeakOrderQueue next = cursor.next;
        // 做清理操作
        if (cursor.owner.get()==null) {
            /**
             * 如果当前的WeakOrderQueue的线程已经不可达了，则
             * 1、如果该WeakOrderQueue中有数据，则将其中的数据全部转移到当前Stack中
             * 2、将当前的WeakOrderQueue的前一个节点prev指向当前的WeakOrderQueue的下一个节点，即将当前的WeakOrderQueue从Queue链表中移除。方便后续GC
             */
            if (cursor.hasFinalData()){
               for (;;){
                   if (cursor.transfer(this)) {
                       success =true;
                   } else {
                       break;
                   }
               }
            }
            if (prev != null) {
                prev.setNext(next);
            }
        } else {
            prev = cursor;
        }
        cursor = next;
    } while (cursor != null && !success);
    this.prev = prev;
    this.cursor = cursor;
    return success;
}
int increaseCapacity(int expectedCapacity) {
    // 获取旧数组长度
    int newCapacity = elements.length;
    // 获取最大长度
    int maxCapacity = this.maxCapacity;
    // 不断扩容（每次扩容2倍），直到达到expectedCapacity或者新容量已经大于等于maxCapacity
    do {
        // 扩容2倍
        newCapacity <<= 1;
    } while (newCapacity < expectedCapacity && newCapacity < maxCapacity);
    // 上述的扩容有可能使新容量newCapacity>maxCapacity，这里取最小值
    newCapacity = Math.min(newCapacity, maxCapacity);
    // 如果新旧容量不相等，进行实际扩容
    if (newCapacity != elements.length) {
        // 创建新数组，复制旧数组元素到新数组，并将新数组赋值给Stack.elements
        elements = Arrays.copyOf(elements, newCapacity);
    }
    return newCapacity;
}
/***********************WeakOrderQueue************************/
public <T> boolean transfer(Stack<T> dst) {
    // 寻找第一个Link（Head不是Link）
    Link head = this.head.link;
    // head == null，表示只有Head一个节点，没有存储数据的节点，直接返回
    if (head == null) {
        return false;
    }
    // 如果第一个Link节点的readIndex索引已经到达该Link对象的DefaultHandle[]的尾部，
    // 则判断当前的Link节点的下一个节点是否为null，如果为null，说明已经达到了Link链表尾部，直接返回，
    // 否则，将当前的Link节点的下一个Link节点赋值给head和this.head.link，进而对下一个Link节点进行操作
    if (head.readIndex == LINK_CAPACITY) {
        if (head.next == null) {
            return false;
        }
        this.head.link = head = head.next;
    }
    // 获取Link节点的readIndex,即当前的Link节点的第一个有效元素的位置
    int srcStart = head.readIndex;
    // 获取Link节点的writeIndex，即当前的Link节点的最后一个有效元素的位置
    int srcEnd = head.get();
    // 计算Link节点中可以被转移的元素个数
    int srcSize = srcEnd - srcStart;
    if (srcSize == 0) {
        return false;
    }
    // 获取转移元素的目的地Stack中当前的元素个数
    final int dstSize = dst.size;
    // 计算期盼的容量
    final int expectedCapacity = dstSize + srcSize;
    /**
     * 如果expectedCapacity大于目的地Stack的长度
     * 1、对目的地Stack进行扩容
     * 2、计算Link中最终的可转移的最后一个元素的下标
     */
    if (expectedCapacity > dst.elements.length) {
        int actualCapacity = dst.increaseCapacity(expectedCapacity);
        srcEnd = Math.min(srcEnd, actualCapacity - dstSize + srcStart);
    }
    if (srcStart == srcEnd) {
        // The destination stack is full already.
        return false;
    } else {
        // 获取Link节点的DefaultHandle[]
        final DefaultHandle[] srcElems = head.elements;
        // 获取目的地Stack的DefaultHandle[]
        final DefaultHandle[] dstElems = dst.elements;
        // dst数组的大小，会随着元素的迁入而增加，如果最后发现没有增加，那么表示没有迁移成功任何一个元素
        int newDstSize = dstSize;
        for (int i = srcStart; i < srcEnd; i++) {
            final DefaultHandle element = srcElems[i];
            /**
             * 设置element.recycleId 或者 进行防护性判断
             */
            if (element.recycledId == 0) {
                element.recycledId = element.lastRecycledId;
            } else if (element.recycledId != element.lastRecycledId) {
                throw new IllegalStateException("recycled already");
            }
            // 置空Link节点的DefaultHandle[i]
            srcElems[i] = null;
            // 扔掉放弃7/8的元素
            if (dst.dropHandle(element)) {
                continue;
            }
            // 将可转移成功的DefaultHandle元素的stack属性设置为目的地Stack
            element.stack = dst;
            // 将DefaultHandle元素转移到目的地Stack的DefaultHandle[newDstSize ++]中
            dstElems[newDstSize++] = element;
        }
        if (srcEnd == LINK_CAPACITY && head.next != null) {
            this.head.reclaimSpace(LINK_CAPACITY);
            // 将Head指向下一个Link，也就是将当前的Link给回收掉了
            // 假设之前为Head -> Link1 -> Link2，回收之后为Head -> Link2
            this.head.link = head.next;
        }
        // 重置readIndex
        head.readIndex = srcEnd;
        // 表示没有被回收任何一个对象，直接返回
        if (dst.size == newDstSize) {
            return false;
        }
        // 将新的newDstSize赋值给目的地Stack的size
        dst.size = newDstSize;
        return true;
    }
}
private boolean hasFinalData() {
    return tail.readIndex != tail.get();
}

总体步骤：

首先获取当前的 Stack 中的 DefaultHandle 对象中的元素个数。
如果为 0，则从其他线程的与当前的 Stack 对象关联的 WeakOrderQueue 中获取元素，并转移到 Stack 的 DefaultHandle[] 中（每一次 pop 只转移一个有元素的 Link），如果转移不成功，说明没有元素可用，直接返回 null；如果转移成功，则重置 size属性 = 转移后的 Stack 的 DefaultHandle[] 的 size，之后直接获取 Stack 对象中 DefaultHandle[] 的最后一位元素，然后将该元素置为 null，之后做防护性检测，最后重置当前的 stack 对象的 size 属性以及获取到的 DefaultHandle 对象的 recycledId 和 lastRecycledId 回收标记，返回 DefaultHandle 对象。

scavenge()转移的流程：

首先设置当前操作的 WeakOrderQueue cursor，如果为 null，则赋值为 stack.head 节点，如果 stack.head 为 null，则表明外部线程没有回收过当前线程创建的 User 对象，则直接返回 false；如果不为 null，则继续向下执行；
首先对当前的 cursor 进行元素的转移，如果转移成功，则跳出循环，设置 prev 和 cursor 属性；如果转移不成功，获取下一个线程 Y 中的与当前线程的 Stack 对象关联的 WeakOrderQueue，如果该 queue 所属的线程 Y 还可达，则直接设置 cursor 为该 queue，进行下一轮循环；如果该 queue 所属的线程 Y 不可达了，则判断其内是否还有元素，如果有，全部转移到当前线程的 Stack 中，之后将线程 Y 的 queue 从查询 queue 链表中移除。

元素转移的细节流程：

寻找 cursor 节点中的第一个 Link（即 Head.link，注意：Head 不是 Link），如果为 null，则表示没有数据，直接返回；否则，
如果第一个 Link 节点的 readIndex 索引已经到达该 Link 对象的 DefaultHandle[] 的尾部，则判断当前的 Link 节点的下一个节点是否为 null，如果为 null，说明已经达到了 Link 链表尾部，直接返回，否则，将当前的 Link 节点的下一个 Link 节点赋值给 head 和 this.head.link，进而对下一个 Link 节点进行操作；
获取 Link 节点的 readIndex，即当前的 Link 节点的第一个有效元素的位置
获取 Link 节点的 writeIndex，即当前的 Link 节点的最后一个有效元素的位置
计算 Link 节点中可以被转移的元素个数，如果为 0，表示没有可转移的元素，直接返回，否则；
获取转移元素的目的地 Stack 中当前的元素个数并计算期盼的容量 expectedCapacity，如果 expectedCapacity 大于目的地 Stack 的长度，则先对目的地 Stack 进行扩容，计算 Link 中最终的可转移的最后一个元素的下标；
如果发现目的地 Stack 已经满了，则直接返回 false；否则
获取 Link 节点的 DefaultHandle[] 和目的地 Stack 的 DefaultHandle[]
根据可转移的起始位置和结束位置对 Link 节点的 DefaultHandle[] 进行循环操作：
置空 Link 节点的 DefaultHandle[i]，扔掉放弃 7/8 的元素，将可转移成功的 DefaultHandle 元素的stack属性设置为目的地 Stack，最后将 DefaultHandle 元素转移到目的地 Stack 的 DefaultHandle[newDstSize++] 中
如果当前被遍历的 Link 节点的 DefaultHandle[] 已经被掏空了，并且该 Link 节点还有下一个 Link 节点，则先将当前的 Link 节点所占的内存空间释放（即为可共享空间 + LINK_CAPACITY），之后将当前的 Link 节点从 Link 链表中删除；
重置当前 Link 的 readIndex
如果上述一票操作后，没有被回收任何一个对象，直接返回 fasle，否则将新的 newDstSize 设置给 stack.size，返回 true。

所以，每一次转移其实只会针对一个有元素的 Link 进行操作，这样就不会太影响查找性能。

五、流程总结

5.1 同线程获取对象

5.2 同线程回收对象

5.3 异线程回收对象

5.4 从异线程获取对象

六、线程同步问题

假设线程 A 进行 get，线程 B 也进行 get，无锁（二者各自从自己的 stack 或者从各自的 weakOrderQueue 中进行获取）
假设线程 A 进行 get 对象 X，线程 B 进行 recycle 对象 X，无锁（假设线程 A 无法直接从其 Stack 获取，从 WeakOrderQueue 进行获取，由于 stack.head 是 volatile 的，线程 B recycle 的对象 X 可以被线程 A 立即获取）
假设线程 C 和线程 B recycle 线程 A 的对象 X，此时需要加锁：假设线程 B 和线程 C 同时回收线程 A 的对象时，有可能会同时 newQueue，就可能同时 setHead，所以这里需要加锁。以 head == null 的时候为例，
- 加锁：线程 B 先执行，则 head = 线程B的queue；之后线程 C 执行，此时将当前的 head 也就是线程 B 的 queue 作为线程 C 的 queue 的 next，组成链表，之后设置 head 为线程 C 的 queue
- 不加锁：线程 B 先执行 queue.setNext(head)，此时线程 B 的 queue.next = null；然后线程 C 执行 queue.setNext(head)，线程 C 的 queue.next = null；线程 B 执行 head = queue，设置 head 为线程 B 的 queue；线程 C 执行 head = queue，设置 head 为线程 C 的 queue，注意：此时线程 B 和线程 C 的 queue 没有连起来，则之后的 pop() 就不会从 B 进行查询。（B 就是资源泄露）

所以，可以看出在实际使用中，Recycler 几乎是一个无锁的对象回收池。

七、防止资源泄露的措施

当我们删除 FastThreadLocal<Stack> threadLocal 中线程 A 的 stack 对象时，会从 FastThreadLocal<Map<Stack<?>, WeakOrderQueue>> DELAYED_RECYCLED 对象（注意：该对象是类变量）中删除 key 为 stack 对象的 Entry；
FastThreadLocal<Map<Stack, WeakOrderQueue>> DELAYED_RECYCLED 使用 WeakHashMap：当 Stack 没有强引用可达时，整个 Entry{Stack, WeakOrderQueue} 都会加入相应的弱引用队列等待回收；
Stack.WeakReference threadRef：假设该线程对象在外界已经没有强引用了，那么实际上该线程对象就可以被回收了。但是如果 Stack 用的是强引用，那么虽然外界不再对该线程有强引用，但是该 stack 对象还持有强引用（假设用户存储了 DefaultHandle 对象，然后一直不释放，而 DefaultHandle 对象又持有 stack 引用），导致该线程对象无法释放。
WeakOrderQueue.WeakReference owner：与 Stack.WeakReference threadRef 相同。

将 DefaultHandle item 添加到 WeakOrderQueue中时，需要 item.stack = null：如果使用者在将 DefaultHandle 对象压入队列后，将 Stack 设置为 null，但是此处的 DefaultHandle 是持有 stack 的强引用的，则 Stack 对象无法回收；而且由于此处 DefaultHandle 是持有 stack 的强引用，WeakHashMap 中对应 stack 的 WeakOrderQueue 也无法被回收掉了，导致内存泄漏。
Head.finalize()：在该对象被真正的回收前，会循环释放当前的 WeakOrderQueue 中的 Link 链表所占用的所有共享空间 availableSharedCapacity，如果不释放，否则该值将不会增加，影响后续的Link的创建

附、bug 记录https://github.com/netty/netty/issues/8220，该bug将会在4.1.30的版本中修复。

本文转载自 netty源码分析4 - Recycler对象池的设计

参考：

《Netty 对象池实践优化》：https://blog.csdn.net/zhousenshan/article/details/82942381
《Netty轻量级对象池实现分析》：https://www.cnblogs.com/hzmark/p/netty-object-pool.html

每天用心记录一点点。内容也许不重要，但习惯很重要！