netty源码之FastThreadLocal

ゝ一纸荒年。 2023-01-02 10:30 181阅读 0赞

# FastThreadLocal #

FastThreadLocal是ThreadLocal的一个变种实现，FastThreadLocal比ThreadLocal的性能更高，但是也有一定的局限性。

## ThreadLocal的使用 ##

ThreadLocal同一线程在某地方进行设置，在随后的任意地方都可以获取到。从而可以用来保存线程上下文信息。例如Spring的事务管理，用ThreadLocal存储Connection，从而各个DAO可以获取同一Connection，可以进行事务回滚，提交等操作。

package com.morris.netty.code.fastthreadlocal;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.BrokenBarrierException;
    import java.util.concurrent.CyclicBarrier;
    
    @Slf4j
    public class ThreadLocalDemo { 
    
        public static void main(String[] args) { 
            ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
            CyclicBarrier cyclicBarrier = new CyclicBarrier(2);
    
            new Thread(()->{ 
                try { 
                    cyclicBarrier.await();
                    threadLocal.set(1);
                    log.info("threadlocal: {}", threadLocal.get());
                } catch (InterruptedException | BrokenBarrierException e) { 
                    e.printStackTrace();
                } finally { 
                    threadLocal.remove();
                }
            }, "t1").start();
    
            new Thread(()->{ 
                try { 
                    cyclicBarrier.await();
                    threadLocal.set(2);
                    log.info("threadlocal: {}", threadLocal.get());
                } catch (InterruptedException | BrokenBarrierException e) { 
                    e.printStackTrace();
                } finally { 
                    threadLocal.remove();
                }
            }, "t2").start();
        }
    }

最佳实践为：

try { 
        // other
    } finally { 
        threadLocal.remove();
    }

一定要在finally处执行remove方法，否则会造成内存泄漏。

## FastThreadLocal的使用 ##

FastThreadLocal用法上完全兼容ThreadLocal。

package com.morris.netty.code.fastthreadlocal;
    
    import io.netty.util.concurrent.FastThreadLocal;
    import io.netty.util.concurrent.FastThreadLocalThread;
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.BrokenBarrierException;
    import java.util.concurrent.CyclicBarrier;
    
    @Slf4j
    public class FastThreadLocalDemo { 
    
        public static void main(String[] args) { 
            FastThreadLocal<Integer> threadLocal = new FastThreadLocal<>();
            CyclicBarrier cyclicBarrier = new CyclicBarrier(2);
    
            new FastThreadLocalThread(() -> { 
                try { 
                    cyclicBarrier.await();
                    threadLocal.set(1);
                    log.info("threadlocal: {}", threadLocal.get());
                } catch (InterruptedException | BrokenBarrierException e) { 
                    e.printStackTrace();
                }
            }, "t1").start();
    
            new FastThreadLocalThread(() -> { 
                try { 
                    cyclicBarrier.await();
                    threadLocal.set(2);
                    log.info("threadlocal: {}", threadLocal.get());
                } catch (InterruptedException | BrokenBarrierException e) { 
                    e.printStackTrace();
                }
            }, "t2").start();
        }
    
    }

使用FastThreadLocal不用像ThreadLocal那样在finally中进行remove()操作，这是因为这里使用的是FastThreadLocalThread，而不是普通的Thread。

构造FastThreadLocalThread的时候，通过FastThreadLocalRunnable对Runnable对象进行了包装：

public FastThreadLocalThread(Runnable target, String name) { 
        super(FastThreadLocalRunnable.wrap(target), name);
        cleanupFastThreadLocals = true;
    }

FastThreadLocalRunnable在执行完之后都会调用FastThreadLocal.removeAll();

public void run() { 
        try { 
            runnable.run();
        } finally { 
            FastThreadLocal.removeAll(); // 自动remove
        }
    }
    
    static Runnable wrap(Runnable runnable) { 
        return runnable instanceof FastThreadLocalRunnable ? runnable : new FastThreadLocalRunnable(runnable);
    }

## FastThreadLocal的快与慢 ##

netty的测试目录下面有2个类:

*  FastThreadLocalFastPathBenchmark
 *  FastThreadLocalSlowPathBenchmark

FastThreadLocalFastPathBenchmark在本机的测试结果如下：

Benchmark                                            Mode  Cnt        Score   Error  Units
    FastThreadLocalFastPathBenchmark.fastThreadLocal    thrpt    2  4975873.682          ops/s
    FastThreadLocalFastPathBenchmark.jdkThreadLocalGet  thrpt    2  3638287.840          ops/s

结论：使用FastThreadLocalThread线程，FastThreadLocal比ThreadLocal的吞吐量高。

FastThreadLocalSlowPathBenchmark在本机的测试结果如下：

Benchmark                                            Mode  Cnt        Score   Error  Units
    FastThreadLocalSlowPathBenchmark.fastThreadLocal    thrpt    2  2899823.235          ops/s
    FastThreadLocalSlowPathBenchmark.jdkThreadLocalGet  thrpt    2  3633241.206          ops/s

结论：使用普通线程，FastThreadLocal比ThreadLocal的吞吐量低。

说明：

*  FastThreadLocal操作元素的时候，使用常量下标在数组中进行定位元素来替代ThreadLocal通过哈希和哈希表，这个改动在频繁使用的时候，效果更加显著。
 *  想要利用上面的特征，线程必须是FastThreadLocalThread或者其子类，默认DefaultThreadFactory都是使用FastThreadLocalThread。
 *  只用在FastThreadLocalThread或者子类的线程使用FastThreadLocal才会更快，因为FastThreadLocalThread定义了属性threadLocalMap类型是InternalThreadLocalMap，如果普通线程会借助ThreadLocal。

## 消除缓存行的伪共享 ##

io.netty.util.internal.InternalThreadLocalMap

// Cache line padding (must be public)
    // With CompressedOops enabled, an instance of this class should occupy at least 128 bytes.
    public long rp1, rp2, rp3, rp4, rp5, rp6, rp7, rp8, rp9;

使用JOL工具查看这个对象占用多少个字节：

io.netty.util.internal.InternalThreadLocalMap object internals:
     OFFSET  SIZE                                               TYPE DESCRIPTION                                                    VALUE
          0    16                                                    (object header)                                                N/A
         16     4                                                int UnpaddedInternalThreadLocalMap.futureListenerStackDepth        N/A
         20     4                                                int UnpaddedInternalThreadLocalMap.localChannelReaderStackDepth    N/A
         24     8                                           Object[] UnpaddedInternalThreadLocalMap.indexedVariables                N/A
         32     8                             Map<Class<?>, Boolean> UnpaddedInternalThreadLocalMap.handlerSharableCache            N/A
         40     8                                      IntegerHolder UnpaddedInternalThreadLocalMap.counterHashCode                 N/A
         48     8                                  ThreadLocalRandom UnpaddedInternalThreadLocalMap.random                          N/A
         56     8                Map<Class<?>, TypeParameterMatcher> UnpaddedInternalThreadLocalMap.typeParameterMatcherGetCache    N/A
         64     8   Map<Class<?>, Map<String, TypeParameterMatcher>> UnpaddedInternalThreadLocalMap.typeParameterMatcherFindCache   N/A
         72     8                                      StringBuilder UnpaddedInternalThreadLocalMap.stringBuilder                   N/A
         80     8                       Map<Charset, CharsetEncoder> UnpaddedInternalThreadLocalMap.charsetEncoderCache             N/A
         88     8                       Map<Charset, CharsetDecoder> UnpaddedInternalThreadLocalMap.charsetDecoderCache             N/A
         96     8                                  ArrayList<Object> UnpaddedInternalThreadLocalMap.arrayList                       N/A
        104     8                                               long InternalThreadLocalMap.rp1                                     N/A
        112     8                                               long InternalThreadLocalMap.rp2                                     N/A
        120     8                                               long InternalThreadLocalMap.rp3                                     N/A
        128     8                                               long InternalThreadLocalMap.rp4                                     N/A
        136     8                                               long InternalThreadLocalMap.rp5                                     N/A
        144     8                                               long InternalThreadLocalMap.rp6                                     N/A
        152     8                                               long InternalThreadLocalMap.rp7                                     N/A
        160     8                                               long InternalThreadLocalMap.rp8                                     N/A
        168     8                                               long InternalThreadLocalMap.rp9                                     N/A
        176     8                                             BitSet InternalThreadLocalMap.cleanerFlags                            N/A
    Instance size: 184 bytes
    Space losses: 0 bytes internal + 0 bytes external = 0 bytes total

疑问？

*  为什么是填充9个字节？
 *  为什么不是前后两边都填充？