Netty分散式高效能工具類recycler的使用及建立

2022-03-29 19:01:51

recycler的使用

這一小節開始學習recycler相關的知識, recycler是netty實現的一個輕量級物件回收站, 在netty中, recycler的使用也是相當之頻繁的

recycler作用是保證了物件的迴圈利用, 物件使用完可以通過recycler回收, 需要再次使用則從物件池中取出, 不用每次都建立新物件從而減少對系統資源的佔用, 同時也減輕了gc的壓力

這裡看一個範例

public class RecyclerDemo {
    private static final Recycler<User> RECYCLER = new Recycler<User>() {
        @Override
        protected User newObject(Handle<User> handle) {
            return new User(handle);
        }
    };
    static class User{
        private final Recycler.Handle<User> handle;
        public User(Recycler.Handle<User> handle){
            this.handle=handle;
        }
        public void recycle(){
            handle.recycle(this);
        }
    }
    public static void main(String[] args){
        User user1 = RECYCLER.get();
        user1.recycle();
        User user2 = RECYCLER.get();
        user2.recycle();
        System.out.println(user1==user2);
    }
}

首先定義了一個Recycler的成員變數RECYCLER, 在匿名內部類中重寫了newObject方法, 也就是建立物件的方法, 該方法就是使用者自定義的

這裡newObject返回的new User(handle), 代表當回收站沒有此類物件的時候, 可以通過這種方式建立物件

成員變數RECYCLER, 可以用來對此類物件的回收和再利用

定一個了一個靜態內部類User, User中有個成員變數handle, 在構造方法中為其賦值, handle的作用, 就是用於物件回收的

並且定義了一個方法recycle, 方法體中通過handle.recycle(this)這種方式將自身物件進行回收, 通過這步操作, 就可以將物件回收到Recycler中

以上邏輯先做了解, 之後會進行詳細分析

在main方法中, 通過RECYCLER的get方法獲取一個user, 然後進行回收

再通過get方法將回收站的物件取出, 再次進行回收, 最後判斷兩次取出的物件是否為一個物件, 最後結果輸出為true

以上demo就可以說明Recycler的回收再利用的功能

簡單介紹了demo, 我們就詳細的分析Recycler的機制

在Recycler的類的原始碼中, 我們看到這一段邏輯

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型別的物件

每個stack中維護著一個DefaultHandle型別的陣列, 用於盛放回收的物件, 有關stack和執行緒的關係如圖所示:

8-3-1

也就是說在每個Recycler中, 都維護著一個執行緒共用的棧, 用於對一類物件的回收

跟到Stack的構造方法中

Stack(Recycler&lt;T&gt; parent, Thread thread, int maxCapacity, int maxSharedCapacityFactor, 
      int ratioMask, int maxDelayedQueues) {
    this.parent = parent;
    this.thread = thread;
    this.maxCapacity = maxCapacity;
    availableSharedCapacity = new AtomicInteger(max(maxCapacity / maxSharedCapacityFactor, LINK_CAPACITY));
    elements = new DefaultHandle[min(INITIAL_CAPACITY, maxCapacity)];
    this.ratioMask = ratioMask;
    this.maxDelayedQueues = maxDelayedQueues;
}

首先介紹幾個構造方法中初始化的關鍵屬性:

屬性parent表示Reclycer物件自身

屬性thread表示當前stack繫結的哪個執行緒

屬性maxCapacity表示當前stack的最大容量, 表示stack最多能盛放多少個元素

屬性elements, 就表示stack中儲存的物件, 型別為DefaultHandle, 可以被外部物件參照, 從而實現回收

屬性ratioMask是用來控制物件回收的頻率的, 也就是說每次通過Reclycer回收物件的時候, 不是每次都會進行回收, 而是通過該引數控制回收頻率

屬性maxDelayedQueues, 這裡稍微有些複雜, 在很多時候, 一個執行緒建立的物件, 有可能會被另一個執行緒所釋放, 而另一個執行緒釋放的物件是不會放在當前執行緒的stack中的, 而是會存放在一個叫做WeakOrderQueue的資料結構中, 裡面也是存放著一個個DefaultHandle, WeakOrderQueue會存放執行緒1建立的並且線上程2進行釋放的物件

這裡只是稍作了解, 之後的會對此做詳細剖析, 這裡我們只需知道, maxDelayedQueues屬性的意思就是我這個執行緒能回收幾個其他建立的物件的執行緒, 假設當前執行緒是執行緒1, maxDelayedQueues為2, 那麼我執行緒1回收了執行緒2建立的物件, 又回收了執行緒3建立的物件, 那麼不可能回收執行緒4建立的物件了, 因為maxDelayedQueues2, 我只能回收兩個執行緒建立的物件

屬性availableSharedCapacity, 表示線上程1中建立的物件, 在其他執行緒中快取的最大個數, 同樣, 相關邏輯會在之後的內容進行剖析

另外介紹兩個沒有在構造方法初始化的屬性:

private WeakOrderQueue cursor, prev;
private volatile WeakOrderQueue head;

這裡相當於指標, 用於指向WeakOrderQueue的, 這裡也是稍作了解, 之後會進行詳細剖析

有關stack異執行緒之間物件的關係如圖所示(簡略):

8-3-2

我們再繼續介紹Recycler的構造方法, 同時熟悉有關stack各個引數的預設值:

protected Recycler() {
    this(DEFAULT_MAX_CAPACITY_PER_THREAD);
}

這裡呼叫了過載的構造方法, 並傳入了引數DEFAULT_MAX_CAPACITY_PER_THREAD

DEFAULT_MAX_CAPACITY_PER_THREAD的預設值是32768, 在static塊中被初始化的, 我們可以跟進去自行分析

這個值就代表的每個執行緒中, stack中最多回收的元素的個數

繼續跟過載的構造方法

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

這裡又呼叫了過載的構造方法, 並且傳入剛才傳入的32768和MAX_SHARED_CAPACITY_FACTOR

MAX_SHARED_CAPACITY_FACTOR預設值是2, 同樣在static塊中進行了初始化, 有關該屬性的用處稍後講解

繼續跟構造方法:

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

這裡同樣呼叫了過載的構造方法, 傳入了剛才32768和2, 還有兩個屬性RATIO和MAX_DELAYED_QUEUES_PER_THREAD

RATIO也在static中被初始化, 預設值是8

同上, MAX_DELAYED_QUEUES_PER_THREAD的預設值是2倍cpu核數

我們繼續跟構造方法:

protected Recycler(int maxCapacityPerThread, int maxSharedCapacityFactor, 
                   int ratio, int maxDelayedQueuesPerThread) {
    ratioMask = safeFindNextPositivePowerOfTwo(ratio) - 1;
    if (maxCapacityPerThread &lt;= 0) {
        this.maxCapacityPerThread = 0;
        this.maxSharedCapacityFactor = 1;
        this.maxDelayedQueuesPerThread = 0;
    } else {
        this.maxCapacityPerThread = maxCapacityPerThread;
        this.maxSharedCapacityFactor = max(1, maxSharedCapacityFactor);
        this.maxDelayedQueuesPerThread = max(0, maxDelayedQueuesPerThread);
    }
}

這裡將幾個屬性進行了初始化

首先看ratioMask, 這裡的方法safeFindNextPositivePowerOfTwo的引數ratio為8, 該方法的意思就是大於等於8的2的冪次方-1, 這裡就是ratioMask就是7

maxCapacityPerThread是剛才分析的32768, 是一個大於0的數, 所以進入else

maxCapacityPerThread為32768

maxSharedCapacityFactor的值為2

maxDelayedQueuesPerThread的值為2倍CPU核數

我們再回到Stack的構造方法中

Stack(Recycler&lt;T&gt; parent, Thread thread, int maxCapacity, int maxSharedCapacityFactor, 
      int ratioMask, int maxDelayedQueues) {
    this.parent = parent;
    this.thread = thread;
    this.maxCapacity = maxCapacity;
    availableSharedCapacity = new AtomicInteger(max(maxCapacity / maxSharedCapacityFactor, LINK_CAPACITY));
    elements = new DefaultHandle[min(INITIAL_CAPACITY, maxCapacity)];
    this.ratioMask = ratioMask;
    this.maxDelayedQueues = maxDelayedQueues;
}

根據Recycler初始化屬性的邏輯, 我們可以知道Stack中幾個屬性的值:

maxCapacity預設值為32768

ratioMask預設值為7

maxDelayedQueues預設值是兩倍cpu核數

availableSharedCapacity的預設值是32768/2, 也就是16384

以上就是Recycler建立的相關邏輯，更多關於Netty分散式工具類recycler使用的資料請關注it145.com其它相關文章！