netty-recyle

Recycler
初始化
maxCapacityPerThread=32768
maxSharedCapacityFactor=2
maxDelayedQueuesPerThread=6
ratioMask=7

    protected Recycler() {
        this(DEFAULT_MAX_CAPACITY_PER_THREAD);//32768
    }
      protected Recycler(int maxCapacityPerThread) {
        this(maxCapacityPerThread, MAX_SHARED_CAPACITY_FACTOR);//32768 2
    }
    protected Recycler(int maxCapacityPerThread, int maxSharedCapacityFactor) {
        this(maxCapacityPerThread, maxSharedCapacityFactor, RATIO, MAX_DELAYED_QUEUES_PER_THREAD);//32768 2 8 6
    }
    protected Recycler(int maxCapacityPerThread, int maxSharedCapacityFactor,
                       int ratio, int maxDelayedQueuesPerThread) {
        ratioMask = safeFindNextPositivePowerOfTwo(ratio) - 1;
        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);
        }
    }

Recycler.get()
1.调用threadLocal.get()其实就是返回一个Stack没有就创建
2.stack.pop(),没有就调用自己实现的newObject()
3.threadlocal.get()若没有值，会调用到initialize()

    public final T get() {
        if (maxCapacityPerThread == 0) {
            return newObject((Handle<T>) NOOP_HANDLE);
        }
        Stack<T> stack = threadLocal.get();
        DefaultHandle<T> handle = stack.pop();
        if (handle == null) {
            handle = stack.newHandle();
            handle.value = newObject(handle);
        }
        return (T) handle.value;
    }

FastThreadLocal.initialize()
1.调用自己实现的initialValue()
2.setIndexedVariable(index, v);
3.addToVariablesToRemove(threadLocalMap, this);

     private V initialize(InternalThreadLocalMap threadLocalMap) {
        V v = null;
        try {
            v = initialValue();
        } catch (Exception e) {
            PlatformDependent.throwException(e);
        }
        threadLocalMap.setIndexedVariable(index, v);
        addToVariablesToRemove(threadLocalMap, this);
        return v;
    }
     private static void addToVariablesToRemove(InternalThreadLocalMap threadLocalMap, FastThreadLocal<?> variable) {
        Object v = threadLocalMap.indexedVariable(variablesToRemoveIndex);
        Set<FastThreadLocal<?>> variablesToRemove;
        if (v == InternalThreadLocalMap.UNSET || v == null) {
            variablesToRemove = Collections.newSetFromMap(new IdentityHashMap<FastThreadLocal<?>, Boolean>());
            threadLocalMap.setIndexedVariable(variablesToRemoveIndex, variablesToRemove);
        } else {
            variablesToRemove = (Set<FastThreadLocal<?>>) v;
        }

        variablesToRemove.add(variable);
    }

InternalThreadLocalMap.indexedVariable()

  public Object indexedVariable(int index) {
        Object[] lookup = indexedVariables;
        return index < lookup.length? lookup[index] : UNSET;
    }

Recycler 会初始化一个FastThreadLocal

    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
maxCapacity = 32768
maxSharedCapacityFactor = 2
ratioMask = 7
maxDelayedQueues = 6
availableSharedCapacity=16384
INITIAL_CAPACITY=256

	Stack(Recycler<T> 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;
	}

Stack.pop()

  DefaultHandle<T> pop() {
      int size = this.size;
      if (size == 0) {
          if (!scavenge()) {
              return null;
          }
          size = this.size;
      }
      size --;
      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;
  }
  
static final class Stack<T> {
  // we keep a queue of per-thread queues, which is appended to once only, each time a new thread other
  // than the stack owner recycles: when we run out of items in our stack we iterate this collection
  // to scavenge those that can be reused. this permits us to incur minimal thread synchronisation whilst
  // still recycling all items.
  final Recycler<T> parent;
  final Thread thread;
  final AtomicInteger availableSharedCapacity;
  final int maxDelayedQueues;
  private final int maxCapacity;
  private final int ratioMask;
  
  private DefaultHandle<?>[] elements;
  private int size;
  private int handleRecycleCount = -1; // Start with -1 so the first one will be recycled.
  private WeakOrderQueue cursor, prev;
  private volatile WeakOrderQueue head;

Stack.scavenge() 回收内存

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

      // reset our scavenge cursor
      prev = null;
      cursor = head;
      return false;
  }

DefaultHandle

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

      boolean hasBeenRecycled;

      private Stack<?> stack;
      private Object value;

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

      @Override
      public void recycle(Object object) {
          if (object != value) {
              throw new IllegalArgumentException("object does not belong to handle");
          }
          stack.push(this);
      }
  }