关于开源框架:recycler

import io.netty.util.Recycler;
import org.junit.Assert;

public class Entry {

String data;
private Recycler.Handle<Entry> handle;
private static final Recycler<Entry> RECYCLER = new Recycler<Entry>() {
    @Override
    protected Entry newObject(Handle<Entry> handle) {
        return new Entry(handle);
    }
};

public Entry(Recycler.Handle<Entry> handle) {
    this.handle = handle;
}

public void recycle() {
    handle.recycle(this);
}

public String getData() {
    return data;
}

public void setData(String data) {
    this.data = data;
}

public static Entry newInstance(String data) {
// get入口
    Entry entry = RECYCLER.get();
    entry.setData(data);
    return entry;
}

public static void main(String[] args) {
    Entry entry =Entry.newInstance("one");
    // 回收入口
    entry.recycle();
    Entry entry1 = Entry.newInstance("two");
    Assert.assertSame(entry1, entry);
}

}

get函数：

public final T get() {
// 如果禁止回收
    if (maxCapacityPerThread == 0) {
        return newObject((Handle<T>) NOOP_HANDLE);
    }
    // 获取以后线程的stack。第一次调用会触发初始化函数
    Stack<T> stack = threadLocal.get();
    // 从stack获取对象
    DefaultHandle<T> handle = stack.pop();
    if (handle == null) { //如果没有获取到就构建一个 DefaultHandle和对象绑定
        handle = stack.newHandle();
        // newObject是用户重写的
        handle.value = newObject(handle);
    }
    return (T) handle.value;
}

stack的初始化：

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.pop()办法：

    DefaultHandle<T> pop() {
        int size = this.size;
        if (size == 0) { // 如果stack中没有数据，本人回收的对象会间接放在stack中
        // 从其它线程回收对象的queue获取
            if (!scavenge()) {
                return null;
            }
            size = this.size;
        }
        size --;
        // stack底层用elements[]这个数组来存储数据
        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;
    }

scavenge办法：

    boolean scavenge() {
        // continue an existing scavenge, if any
        if (scavengeSome()) {
            return true;
        }

        //重置
        prev = null;
        cursor = head;
        return false;
    }

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

     boolean scavengeSome() {
        WeakOrderQueue cursor = this.cursor;
        if (cursor == null) {
            cursor = head;
            if (cursor == null) {
                return false;
            }
        }

        boolean success = false;
        WeakOrderQueue prev = this.prev;
        do {
            if (cursor.transfer(this)) {
                success = true;
                break;
            }

            WeakOrderQueue next = cursor.next;
                /**
                 * 如果以后的WeakOrderQueue的线程曾经不可达了，则
                 * 1、如果该WeakOrderQueue中有数据，则将其中的数据全副转移到以后Stack中
                 * 2、将以后的WeakOrderQueue的前一个节
                 *   点prev指向以后的WeakOrderQueue的下一个节点，
                 *   行将以后的WeakOrderQueue从Queue链表中移除。不便后续GC
                 */
            if (cursor.owner.get() == null) {
                if (cursor.hasFinalData()) {
                    for (;;) {
                        if (cursor.transfer(this)) {
                            success = true;
                        } else {
                            break;
                        }
                    }
                }
                if (prev != null) {
                    prev.next = next;
                }
            } else {
                prev = cursor;
            }

            cursor = next;

        } while (cursor != null && !success);

        this.prev = prev;
        this.cursor = cursor;
        return success;
    }

transfer办法：

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

//回收
recycle办法：最终进入stack.push

   void push(DefaultHandle<?> item) {
        Thread currentThread = Thread.currentThread();
        if (thread == 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, we need to signal that the push
            // happens later.
            pushLater(item, currentThread);
        }
    }

pushNow办法：

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

pushLater办法：

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;
            }
            // 如果这个stack的容量还没用完，就调配一个queue，在调配queue的时候会将queue通过头插法插入stack保护的队列
            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);
    }


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

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

add：将回收元素退出队列

    void add(DefaultHandle<?> handle) {
        handle.lastRecycledId = id;

        Link tail = this.tail;
        int writeIndex;
         // 判断一个Link对象是否曾经满了：
        // 如果没满，间接增加；
        // 如果曾经满了，创立一个新的Link对象，之后重组Link链表
        if ((writeIndex = tail.get()) == LINK_CAPACITY) {
            if (!reserveSpace(availableSharedCapacity, LINK_CAPACITY)) {
                // Drop it.
                return;
            }
            // We allocate a Link so reserve the space
            this.tail = tail = tail.next = new Link();
            writeIndex = tail.get();
        }
        tail.elements[writeIndex] = handle;
         /**
         * 如果使用者在将DefaultHandle对象压入队列后，
         * 将Stack设置为null，然而此处的DefaultHandle是持有stack的强援用的，则Stack对象无奈回收；
         * 而且因为此处DefaultHandle是持有stack的强援用，WeakHashMap中对应stack的WeakOrderQueue也无奈被回收掉了，导致内存透露。
         */
        handle.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.lazySet(writeIndex + 1);
    }

每个线程都会有一个FastThreadLocal<Map<Stack<?>, WeakOrderQueue>> DELAYED_RECYCLED。装载着此线程回收其余线程产生的对象。还含有一个FastThreadLocal<Stack<T>> threadLocal，装着这个线程回收的对象和其余线程回收的对象（迁徙过去的）。stack 含有一个weekQueue指针，其余线程回收对象的时候会new一个queue，
而后头插法退出队列。当scavenge的时候，会从head开始遍历，找到一个有数据的queue进行迁徙，将外面的对象挪动到elements[]中去。

参考博客：https://www.jianshu.com/p/854…

关于开源框架:recycler

评论

发表回复取消回复

更多文章

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

深入解析：基于Delta的线性数据结构模型，打造高效富文本编辑器

轻松管理社交媒体：使用Automa插件实现一键拉黑功能

关于开源框架:recycler

评论

发表回复 取消回复

更多文章

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

深入解析：基于Delta的线性数据结构模型，打造高效富文本编辑器

轻松管理社交媒体：使用Automa插件实现一键拉黑功能

发表回复取消回复