解读io.netty.util.Recycler

netty使用基于thread-local的轻量级对象池Recycler对ChannelOutboundBuffer进行回收。当ChannelOutboundBuffer第一次被实例化且使用完毕后，会回收到Recycler中（见下面的recyle方法），下次需要用时，直接从Recycler中取（见下面的get方法），避免了再次实例化和垃圾回收的开销。

Java代码  

1. public abstract class Recycler<T> {  
2.     private final ThreadLocal<Stack<T>> threadLocal = new ThreadLocal<Stack<T>>() {  
3.         @Override  
4.         protected Stack<T> initialValue() {  
5.             return new Stack<T>(Recycler.this, Thread.currentThread());  
6.         }  
7.     };  
8.     public final T get() {  
9.         Stack<T> stack = threadLocal.get();  
10.         T o = stack.pop();  
11.         if (o == null) {  
12.             o = newObject(stack);  
13.         }  
14.         return o;  
15.     }  
16.     public final boolean recycle(T o, Handle handle) {  
17.         @SuppressWarnings("unchecked")  
18.         Stack<T> stack = (Stack<T>) handle;  
19.         if (stack.parent != this) {  
20.             return false;  
21.         }  
22.         if (Thread.currentThread() != stack.thread) {  
23.             return false;  
24.         }  
25.         stack.push(o);  
26.         return true;  
27.     }  
28.     protected abstract T newObject(Handle handle);  
29.     public interface Handle { }  
30.     static final class Stack<T> implements Handle {  
31.         private static final int INITIAL_CAPACITY = 256;  
32.         final Recycler<T> parent;  
33.         final Thread thread;  
34.         private T[] elements;  
35.         private int size;  
36.         private final Map<T, Boolean> map = new IdentityHashMap<T, Boolean>(INITIAL_CAPACITY);  
37.         @SuppressWarnings({ "unchecked", "SuspiciousArrayCast" })  
38.         Stack(Recycler<T> parent, Thread thread) {  
39.             this.parent = parent;  
40.             this.thread = thread;  
41.             elements = newArray(INITIAL_CAPACITY);  
42.         }  
43.         T pop() {  
44.             int size = this.size;  
45.             if (size == 0) {  
46.                 return null;  
47.             }  
48.             size --;  
49.             T ret = elements[size];  
50.             elements[size] = null;  
51.             map.remove(ret);  
52.             this.size = size;  
53.             return ret;  
54.         }  
55.   
56.         void push(T o) {  
57.             if (map.put(o, Boolean.TRUE) != null) {  
58.                 throw new IllegalStateException("recycled already");  
59.             }  
60.   
61.             int size = this.size;  
62.             if (size == elements.length) {  
63.                 T[] newElements = newArray(size << 1);  
64.                 System.arraycopy(elements, 0, newElements, 0, size);  
65.                 elements = newElements;  
66.             }  
67.   
68.             elements[size] = o;  
69.             this.size = size + 1;  
70.         }  
71.   
72.         @SuppressWarnings({ "unchecked", "SuspiciousArrayCast" })  
73.         private static <T> T[] newArray(int length) {  
74.             return (T[]) new Object[length];  
75.         }  
76.     }