编程语言
首页 > 编程语言> > netty源码分析 - Recycler 对象池的设计

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

作者:互联网

目录

本文转载至 netty源码分析4 - 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对象,用于处理该对象的回收操作。

注意:

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);
}

步骤:

  1. main 线程先调用 userRecycler.get()从userRecycler 中获取 User 对象 user1,首次 userRecycler 中没有 User 对象,调用n ewObject 方法进行创建,之后返回;
  2. 对 user1 进行赋值并使用
  3. 使用结束之后,对 user1 恢复出厂设置(这一步需要使用者自己进行处理,Recycler 不会做)
  4. main 线程将 user1 回收到对象池
  5. 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);
}

步骤:

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

三、数据结构

3.1 物理数据结构图

recycler1.png

说明:

  1. 每一个 Recycler 对象包含一个 FastThreadLocal<Stack> threadLocal 实例;

    每一个线程包含一个 Stack 对象,该 Stack 对象包含一个 DefaultHandle[],而 DefaultHandle 中有一个属性 T value,用于存储真实对象。也就是说,每一个被回收的对象都会被包装成一个 DefaultHandle 对象(而该 DefaultHandle 对象实际上也作为真是对象的一个属性 -- 见“二、使用姿势”);

  2. Recyler 类包含一个类对象 FastThreadLocal<Map<Stack<?>, WeakOrderQueue>> DELAYED_RECYCLED;

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

3.2 逻辑数据结构图(重要)

recycler2.png

说明:(假设线程A创建的对象)

  1. 线程 A 回收 user1 时,直接将 user1 的 DefaultHandle 对象(内部包含 user1 对象)压入 Stack 的 DefaultHandle[] 中;

  2. 线程 B 回收 user1 时,会首先从其 Map<Stack<?>, WeakOrderQueue> 对象中获取 key=线程A的Stack 对象的 WeakOrderQueue,然后直接将 user1 的 DefaultHandle 对象(内部包含user1对象)压入该 WeakOrderQueue 中的 Link 链表中的尾部 Link 的 DefaultHandle[]中,同时,这个 WeakOrderQueue 会与线程 A 的 Stack 中的 head 属性进行关联,用于后续对象的 pop 操作;

  3. 当线程 A 从对象池获取对象时,如果线程 A 的 Stack 中有对象,则直接弹出;如果没有对象,则先从其 head 属性所指向的 WeakorderQueue 开始遍历 queue 链表,将 User 对象从其他线程的 WeakOrderQueue 中转移到线程 A 的 Stack 中(一次 pop 操作只转移一个包含了元素的 Link),再弹出。

注意:(假设线程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 总体步骤:

  1. 如果 maxCapacityPerThread == 0,则禁用回收功能:新建 User 对象,将一个什么都不做的 NOOP_HANDLE 塞入 User 对象,进而不做回收操作;否则

  2. 获取当前线程的 Stack对象,如果没有,则新建一个 Stack 对象,在 Stack 对象的构造器中,会新建一个 DefaultHandle[],默认大小为 4k;

  3. 从 stack 对象中 pop 出一个 DefaultHandle 来,如果不为 null,直接返回 DefaultHandle 存储的真实对象 value;如果为 null,则新建一个 DefaultHandle 对象,之后新建 User 对象,并进行 DefaultHandle 对象和 User 对象的绑定,最终返回 user 对象。

Stack#pop的步骤:

  1. 首先获取当前的 Stack 中的 DefaultHandle 对象中的元素个数。

  2. 如果不为 0,直接获取 Stack 对象中 DefaultHandle[] 的最后一位元素,然后将该元素置为 null,之后做防护性检测,最后重置当前的 stack 对象的 size 属性以及获取到的 DefaultHandle 对象的 recycledId 和 lastRecycledId 回收标记,返回 DefaultHandle 对象。

  3. 如果为 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 步骤:

  1. 首先 Recycler 对象做防护性检测,并且做多次回收的检测(netty-4.1.28 是没有这个检测的,笔者提了一个 bug 给 netty);
    之后向 stack 对象中 push 当前的 DefaultHandle 对象

  2. stack 先检测当前的线程是否是创建 stack 的线程,如果不是,则走异线程回收逻辑;如果是,则首先判断是否重复回收,然后判断 stack 的 DefaultHandle[] 中的元素个数是否已经超过最大容量(4k),如果是,直接返回;如果不是,则计算当前元素是否需要回收(netty 为了防止 Stack 的 DefaultHandle[] 数组发生爆炸性的增长,所以默认采取每 8 个元素回收一个,扔掉 7 个的策略),如果不需要回收,直接返回;如果需要回收,则

  3. 判断当前的 DefaultHandle[] 是否还有空位,如果没有,以 maxCapacity 为最大边界扩容 2 倍,之后拷贝旧数组的元素到新数组,然后将当前的 DefaultHandle 对象放置到 DefaultHandle[] 中

  4. 最后重置 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 步骤:

  1. 首先获取当前线程的 Map<Stack<?>, WeakOrderQueue> 对象,如果没有就创建一个空 map;

  2. 然后从 map 对象中获取 key 为当前的 Stack 对象的 WeakOrderQueue;

  3. 如果存在,则判断该 queue 是不是 WeakOrderQueue.DUMMY 对象,如果是,直接返回,不回收对象;如果不是则调用 WeakOrderQueue#add(DefaultHandle item) 添加对象;

  4. 如果不存在,则先判断当前的 map 的数量是不是已经达到或者超过 maxDelayedQueues 限制了(默认最大为 2 * cpu 核数个),如果是,则直接塞入一个{当前的 Stack 对象, WeakOrderQueue.DUMMY 对象},最后扔掉当前的 DefaultHandle 对象;如果不是,则会新建 WeakOrderQueue,之后将{当前的 Stack 对象, 创建好的 WeakOrderQueue 对象}添加到map中,最后调用 WeakOrderQueue#add(DefaultHandle item) 添加对象。

WeakOrderQueue 的创建流程:

  1. 首先判断当前的 Stack 对象的可用共享内存(初始默认值为 2k)是否还有足够的空间(LINK_CAPACITY,默认为16)来存放一个 Link,如果不够了,直接返回;否则,使用 cas+ 无限重试的方式设置 Stack 的可用共享内存 = 当前的可用共享内存大小 - 16,也就是分配一个 Link 大小的空间;

  2. 如果分配成功,则会新建一个 WeakOrderQueue 对象:在 WeakOrderQueue 构造器中,首先创建一个 Link 对象,而每一个 Link 对象内部都包含一个 DefaultHandle[LINK_CAPACITY],用于存放回收的对象;然后创建一个 Head 对象,之后将 Head.link 设置为刚刚创建出来的 Link 对象,用于后续的对象 pop 操作;最后设置当前的 WeakOrderQueue 所属的线程为当前线程。

  3. 先将原本的 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)添加对象流程:

  1. 首先设置 item.lastRecycledId = 当前 WeakOrderQueue 的 id

  2. 然后看当前的 WeakOrderQueue 中的 Link 节点链表中的尾部 Link 节点的 DefaultHandle[] 中的元素个数是否已经达到 LINK_CAPACITY(16)

  3. 如果不是,则直接将当前的 DefaultHandle 元素插入尾部 Link 节点的 DefaultHandle[] 中,之后置空当前的 DefaultHandle 元素的 stack 属性,最后记录当前的 DefaultHandle[] 中的元素数量;

  4. 如果是,则先从当前的可共享容量中划分一块新的 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();
}

总体步骤:

  1. 首先获取当前的Stack中的DefaultHandle对象中的元素个数。

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

scavenge()转移的流程:

  1. 首先设置当前操作的WeakOrderQueue cursor,如果为null,则赋值为stack.head节点,如果stack.head为null,则表明外部线程没有回收过当前线程创建的User对象,则直接返回false;如果不为null,则继续向下执行;

  2. 首先对当前的cursor进行元素的转移,如果转移成功,则跳出循环,设置prev和cursor属性;如果转移不成功,获取下一个线程Y中的与当前线程的Stack对象关联的WeakOrderQueue,如果该queue所属的线程Y还可达,则直接设置cursor为该queue,进行下一轮循环;如果该queue所属的线程Y不可达了,则判断其内是否还有元素,如果有,全部转移到当前线程的Stack中,之后将线程Y的queue从查询queue链表中移除。

元素转移的细节流程:

  1. 寻找cursor节点中的第一个Link(即Head.link,注意:Head不是Link),如果为null,则表示没有数据,直接返回;否则,

  2. 如果第一个Link节点的readIndex索引已经到达该Link对象的DefaultHandle[]的尾部,则判断当前的Link节点的下一个节点是否为null,如果为null,说明已经达到了Link链表尾部,直接返回,否则,将当前的Link节点的下一个Link节点赋值给head和this.head.link,进而对下一个Link节点进行操作;

  3. 获取Link节点的readIndex,即当前的Link节点的第一个有效元素的位置
  4. 获取Link节点的writeIndex,即当前的Link节点的最后一个有效元素的位置
  5. 计算Link节点中可以被转移的元素个数,如果为0,表示没有可转移的元素,直接返回,否则;
  6. 获取转移元素的目的地Stack中当前的元素个数并计算期盼的容量expectedCapacity,如果expectedCapacity大于目的地Stack的长度,则先对目的地Stack进行扩容,计算Link中最终的可转移的最后一个元素的下标;
  7. 如果发现目的地Stack已经满了,则直接返回false;否则
  8. 获取Link节点的DefaultHandle[] 和 目的地Stack的DefaultHandle[]
  9. 根据可转移的起始位置和结束位置对Link节点的DefaultHandle[]进行循环操作:
  10. 置空Link节点的DefaultHandle[i],扔掉放弃7/8的元素,将可转移成功的DefaultHandle元素的stack属性设置为目的地Stack,最后将DefaultHandle元素转移到目的地Stack的DefaultHandle[newDstSize ++]中
  11. 如果当前被遍历的Link节点的DefaultHandle[]已经被掏空了,并且该Link节点还有下一个Link节点,则先将当前的Link节点所占的内存空间释放(即为可共享空间 + LINK_CAPACITY),之后将当前的Link节点从Link链表中删除;
  12. 重置当前Link的readIndex
  13. 如果上述一票操作后,没有被回收任何一个对象,直接返回fasle,否则将新的newDstSize设置给stack.size,返回true。

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

五、流程总结

5.1 同线程获取对象

5.2 同线程回收对象

5.3 异线程回收对象

5.4 从异线程获取对象

六、线程同步问题

  1. 假设线程 A 进行 get,线程 B 也进行 get,无锁(二者各自从自己的 stack 或者从各自的 weakOrderQueue 中进行获取)

  2. 假设线程 A 进行 get 对象 X,线程 B 进行 recycle 对象X,无锁(假设 A 无法直接从其 Stack 获取,从 WeakOrderQueue 进行获取,由于 stack.head 是 volatile 的,线程 B recycle 的对象 X 可以被线程 A 立即获取)

  3. 假设线程 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 几乎是一个无锁的对象回收池。

七、防止资源泄露的措施

  1. 当我们删除 FastThreadLocal<Stack> threadLocal 中线程 A 的 stack 对象时,会从 FastThreadLocal<Map<Stack<?>, WeakOrderQueue>> DELAYED_RECYCLED 对象(注意:该对象是类变量)中删除 key 为 stack 对象的 Entry;

  2. FastThreadLocal<Map<Stack<?>, WeakOrderQueue>> DELAYED_RECYCLED 使用 WeakHashMap:当 Stack 没有强引用可达时,整个 Entry{Stack<?>, WeakOrderQueue} 都会加入相应的弱引用队列等待回收;

  3. Stack.WeakReference threadRef:假设该线程对象在外界已经没有强引用了,那么实际上该线程对象就可以被回收了。但是如果 Stack 用的是强引用,那么虽然外界不再对该线程有强引用,但是该 stack 对象还持有强引用(假设用户存储了 DefaultHandle 对象,然后一直不释放,而 DefaultHandle 对象又持有 stack 引用),导致该线程对象无法释放。

  4. WeakOrderQueue.WeakReference owner:与 Stack.WeakReference threadRef 相同。
    将 DefaultHandle item 添加到 WeakOrderQueue中时,需要 item.stack = null:如果使用者在将 DefaultHandle 对象压入队列后,将 Stack 设置为 null,但是此处的 DefaultHandle 是持有 stack 的强引用的,则 Stack 对象无法回收;而且由于此处 DefaultHandle 是持有 stack 的强引用,WeakHashMap 中对应 stack 的 WeakOrderQueue 也无法被回收掉了,导致内存泄漏。

  5. Head.finalize():在该对象被真正的回收前,会循环释放当前的 WeakOrderQueue 中的 Link 链表所占用的所有共享空间 availableSharedCapacity,如果不释放,否则该值将不会增加,影响后续的Link的创建

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

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

参考:

  1. Netty之Recycler

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

标签:netty,Link,Recycler,对象,源码,线程,DefaultHandle,WeakOrderQueue,Stack
来源: https://www.cnblogs.com/binarylei/p/11094897.html