2021-05-05 16:51  阅读(122)
文章分类:Netty 学习之旅 文章标签:NettyNetty 学习
©  原文作者:中间件兴趣圈 原文地址:https://blog.csdn.net/prestigeding/article/details/53977445

1、java.lang.ThreadLocal概况

ThreadLocal,本地线程变量,每个线程保留着一个共享变量的副本。其实我不太认可每个线程保存共享变量的一个副本这个说法,而是ThreadLocal是线程上下文环境的一种实现方式而已。就以数据库事务这一常用场景来举例说明,比如每个线程需要访问数据库,就需要获取数据库的连接Connection对象,在实际中,我们会用数据库连接池来重复利用Connection,首先线程池,这里是一个共享变量,线程池的实现必须保证多个线程同时从线程池中获取Connection不会重复,然后每个线程使用单独的Connection,并且该Connection被一个线程占用后,其他线程压根就不会使用到,也不会试图去使用一个已经被其他线程占用的Connection对象。由于一个线程在执行过程中,可能需要多次操作数据库,所以我们的设计就是一个线程在执行过程中,只与一个Connection打交道,也就是整个线程的执行过程(执行环境)需要保存刚获取的Connection,最简单有效的办法,就是把这个Connection保存在线程对象的某个属性中,ThreadLocal就是干这事的。ThreadLocal并不是为这个Connection复制一份,多个线程都使用这个副本,不是这样的,一个Connection对象在任意时刻,没有被复制多份。

我的观点:ThreadLocal是线程一个本地变量,是线程的执行上下文。

2、 从ThreadLocal get方法源码分析其实现逻辑

        /**
             * Returns the value in the current thread's copy of this
             * thread-local variable.  If the variable has no value for the
             * current thread, it is first initialized to the value returned
             * by an invocation of the {@link #initialValue} method.
             *
             * @return the current thread's value of this thread-local
             */
            public T get() {
                Thread t = Thread.currentThread();    //@1
                ThreadLocalMap map = getMap(t);   //@2
                if (map != null) {
                    ThreadLocalMap.Entry e = map.getEntry(this);     //@3
                    if (e != null)
                        return (T)e.value;
                }
                return setInitialValue();                      // @4
            }

代码@1:获取当前线程。

代码@2:从当前线程获取ThreadLocalMap。

        ThreadLocalMap getMap(Thread t) {
    
                return t.threadLocals;
    
         }

这里是直接返回线程对象的threadLocals变量,有点意思吧,所以说ThreadLocal,是线程的本地变量,就是这层意思,真正存放数据的地方,就是线程对象本身,其实接下来的会更加有意思:我们进入ThreadLocalMap源码分析,得知,原来ThreadLocalMap就是一个Map结构(K-V)键值对,关于里面的源码就不一一分析了,ThreadLocalMap(ThreadLocal firstKey, Object firstValue),firstKey 为ThreadLocal,神奇吧,其实这也是为什么Thread的本地变量的数据类型为Map的原型,一个线程可以被多个ThreadLocal关联,每声明一个,就在线程的threadLocals增加为一个键值对,key 为 ThreadLocal,而value为具体存放的对象。

代码@3:如果线程的ThreadLocalMap不为空,则直接返回对,否则进入到代码@4

代码@4:初始化并获取放入ThreadLocal中的变量。

上面就是ThreadLocal的核心设计理念,为了更加直观的说明ThreadLocal原理,举例说明:

        -----------------------------------------------------------------------
        public class ThreadLocalDemo1 {
           private static final ThreadLocal<String> schemaLocal 
                  = new ThreadLocal<String>();
    
            public void test1() {
                String a = schemaLocal.get();
    
                ThreadLocalDemo2 demo2 = new ThreadLocalDemo2();
                demo2.test(a);
            }
    
            public static void main(String[] args) {
                // TODO Auto-generated method stub
    
            }
    
        }
    
        public class ThreadLocalDemo2 {
    
          private static final ThreadLocal<String> slocal = new ThreadLocal<String>();
    
            public void test(String b) {
                String a = slocal.get();
                // 其他代码
                System.out.println(b);
            }
    
            public static void main(String[] args) {
                // TODO Auto-generated method stub
            }
    
        }
    
        public class TestMain {
    
            public static void main(String[] args) {
                // TODO Auto-generated method stub
    
                ThreadLocalDemo1 d = new ThreadLocalDemo1();
                d.test1();
    
            }
    
        }

一个线程调用 ThreadLocalDemo1 的 test1方法,在这个执行链中会涉及到两个ThreadLocal变量,调用ThreadLocal的get方法,首先会获取当前线程,然后从当前线程对象中获取线程内部属性[ThreadLocal.ThreadLocalMap threadLocals = null;],然后从ThreadLocalMap中以ThreadLocal对象为键,从threadLocals map中获取存放的值。

线程的threadLocals值为

        {
    
             ThreadLocalDemo1.schemaLocal  : 该变量中的值,
    
             ThreadLocalDemo2.scloal : 存放在本线程中的值
    
           }

3、 ThreadLocal优化思考

ThreadLocal的数据访问算法,本质上就是Map的访问特性。

我在分析HashMap源码的时候,已经将HashMap的存储结构讲解完毕,如有兴趣,可以浏览一下我的博文:深入理解HashMap:http://blog.csdn.net/prestigeding/article/details/52861420,HashMap根据key的访问速度效率是很快的,为什么呢?因为HashMap根据key的hash,然后会定位到内部的数据槽(该数据是数组结构),众所周知,根据数组的下标访问,访问速度是最快的,也就是说HashMap根据key的定位速度比LinkedList等都快,仅次于数组访问方式,这是因为HashMap多了一步Hash定位槽的过程(当然,如果有Hash冲突那就更慢了)。所以,如果在高并发场景下,需要进一步优化ThreadLocal的访问性能,那就要从线程对象(Thread的threadLocals 数据结构下手了,如果能将数据结构修改为数组,然后每个ThreadLocal对象维护其下标那就完美了)。是的,Netty框架就是为了高并发而生的,由于并发访问的数量很大,一点点的性能优化,就会带来可观的性能提升效应,Netty主要从如下两个方面对ThreadLocal的实现进行优化

  • 线程对象直接提供 set、get方法,以便直接获取线程本地存储相关的变量属性。
  • 将数据存储基于数组存储。

4、Netty关于ThreadLocal机制的优化

由于ThreadLocal是JDK的原生实现,通用性很强,直接扩展进行定制化不是明智的选择,故Netty在优化ThreadLocal的方式是自己另起灶炉,实现ThreadLocal的语义。优化方法如下:

  • 提供一个接口,FastThreadLocalAccess,并对线程池工厂类进行定制,创建的线程继承在java.lang.Thread类,并实现FastThreadLocalAccess接口,提供直接设置,获取线程本地变量的方法。
  • 提供FastThreadLocal类,此类实现ThreadLocal相同的语义。
  • 提供InternalThreadLocalMap类,此类作用类同于java.lang.ThreadLocal.ThreadLocalMap类,用于线程存放真实数据的结构。

4.1 扩展线程对象,提供set,get方法

通过定制的线程池工厂,创建的线程对象为扩展后的线程对象,在Netty中对应为FastThreadLocalThread,该类本身很简单,值得大家注意的是其思想,jdk并发包中提供的线程池实现机制中,提供了线程创建的工厂的扩展点,这里就是其典型的实践。这里附上其源码,不做解读:

        public class FastThreadLocalThread extends Thread implements FastThreadLocalAccess {
    
            private InternalThreadLocalMap threadLocalMap;
    
            public FastThreadLocalThread() { }
    
            public FastThreadLocalThread(Runnable target) {
                super(target);
            }
    
            public FastThreadLocalThread(ThreadGroup group, Runnable target) {
                super(group, target);
            }
    
            public FastThreadLocalThread(String name) {
                super(name);
            }
    
            public FastThreadLocalThread(ThreadGroup group, String name) {
                super(group, name);
            }
    
            public FastThreadLocalThread(Runnable target, String name) {
                super(target, name);
            }
    
            public FastThreadLocalThread(ThreadGroup group, Runnable target, String name) {
                super(group, target, name);
            }
    
            public FastThreadLocalThread(ThreadGroup group, Runnable target, String name, long stackSize) {
                super(group, target, name, stackSize);
            }
    
            /**
             * Returns the internal data structure that keeps the thread-local variables bound to this thread.
             * Note that this method is for internal use only, and thus is subject to change at any time.
             */
            @Override
            public final InternalThreadLocalMap threadLocalMap() {
                return threadLocalMap;
            }
    
            /**
             * Sets the internal data structure that keeps the thread-local variables bound to this thread.
             * Note that this method is for internal use only, and thus is subject to change at any time.
             */
            @Override
            public final void setThreadLocalMap(InternalThreadLocalMap threadLocalMap) {
                this.threadLocalMap = threadLocalMap;
            }
        }

4.2 FastThreadLocal与InternalThreadLocalMap

InternalThreadLocalMap是线程存储本地变量的数据结构,每个线程拥有自己的InternalThreadLocalMap,其作用与java.lang.ThreadLocal.ThreadLocalMap内部类一样,而FastThreadLocal,其语义与ThreadLocal一样,对外表现与ThreadLocal一样。再次重复一下,Netty的InternalThreadLocalMap内部为数组,为什么是数组呢?线程本地变量,要从线程的执行流的角度看,一个线程在执行过程中,会经过多个类,会有多个类中声明有线程本地变量(参考上文说明ThreadLocal时候的举例),所以此处的数组就是保留线程在整个线程的执行过程中,不同的ThreadLocal变量中保存不同的数据,java.lang.ThreadLocal.ThreadLocalMap内部类的实现使用map结构,键为 ThreadLocal对象,而值为真正保存的变量值,InternalThreadLocalMap既然是数组,数组是一维的,数组最终肯定只能保存 真正要保持的变量值,那怎么区分不同的ThreadLocal在InternalThreadLocalMap中的下标呢?Netty采用的方式是将下标保存在FastThreadLocal中,我们知道,一般使用本地线程变量,FastThreadLocal的声明方式,一般是类变量(静态变量),诸如:private static final ThreadLocal aThreadLocal = new ThreadLocal();整个系统ThreadLocal的个数其实不会很多,每个FastThreadLocal在InternalThreadLocalMap的下标(偏移量)在FastThreadLocal加载时候确定,并保持不变。并且每个InternalThreadLocal内部数组的第一元素,存放系统运行中的FastThreadLocal对象。InternalThreadLocalMap的内部数据结构为:

Object[] indexedVariables;

现在举例说明上述理论:

比如整个项目,有A,B,C,D,E5个类中各声明了一个静态的FastThreadLocal变量,类的加载顺序为A , B , D, E, C。

那们 类A中的FastThreadLocal存放在线程变量InternalThreadLocalMap的下标为1,B,为2,D为3,依次内推,

比如线程 T1,在一次请求过程中,需要用的A,E,C三个类中的FastThreadLocalMap,那么线程T1,的InternalThreadLocalMap的水库中的下标为1为A,下标为2,3的元素为空,下标为4为E,下标5存放C中的变量值。

每个线程InternalThreadLocalMap下标为0的是一Set集合,存放的是系统运行中有效的FastThreadLocal变量。

根据这样的存放后,FastThreadLocal 的get,set方法,都是根据下标直接在InternalThreadLocalMap的数组中直接存储,当然,值得一提的是InternalThreadLocalMap中数组元素长度默认为32,如果系统的FastThreadLocal的数量超过32个的话,会成倍扩容。

FastThreadLocal学习的入口,建议从set,get方法入手即可,知道上述原理后,源码的阅读应该比较容易,就不做过多讲解了。


来源:https://blog.csdn.net/prestigeding/article/details/53977445

点赞(0)
版权归原创作者所有,任何形式转载请联系作者; Java 技术驿站 >> hreadLocal原理分析与性能优化思考(思考篇)
上一篇
源码分析Netty线程本地分配机制与PooledByteBuf线程级对象池原理分析
下一篇
Netty Channel 概述