Netty进阶:自顶向下解析FastThreadLocal

FastThreadLocalThread 分析

我们知道EventLoopGroup相当于线程池,而EventLoop是其中的线程,用来执行IO任务和一些handler中的业务逻辑。在Netty进阶:Netty核心NioEventLoop原理解析文章中详解的介绍了EventLoopGroup和EventLoop的构造过程,以及他们如何去执行IO任务等。但是关于NioEventLoop中持有的Executor引用并没有做过多的解释。Executor是JDK提供的一个线程池接口,只有一个execte方法。下面对Netty对Executor的实现做一个详细的阐述。

NioEventLoopGroup的父类MultithreadEventExecutorGroup的构造函数中对Executor的赋值语句如下:

executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());

ThreadPerTaskExecutor是Netty对JDK Exectuor的实现类。这个类的实现非常简单

public final class ThreadPerTaskExecutor implements Executor {
    // 每一个EventLoopGroup对应一个ThreadPerTaskExecutor
    private final ThreadFactory threadFactory;
    // 构造函数
    public ThreadPerTaskExecutor(ThreadFactory threadFactory) {
        if (threadFactory == null) {
            throw new NullPointerException("threadFactory");
        }
        this.threadFactory = threadFactory;
    }
    // 实现Executor的方法
    @Override
    public void execute(Runnable command) {
        threadFactory.newThread(command).start();
    }
}

这里有一个疑惑,Netty为什么不用JDK提供的Exector接口的多个实现(Executors有对ThreadFactory的实现)?

可以看到threadFactory.newThread(command).start();的意思是创建一个新的线程并且启动。我们继续跟进ThreadFactory的实现;

@Override
public Thread newThread(Runnable r) {
    Thread t = newThread(FastThreadLocalRunnable.wrap(r), prefix + nextId.incrementAndGet());
    // 一般daemon为false,意思是不设置为守护线程
    if (t.isDaemon() != daemon) {
        t.setDaemon(daemon);
    }
    // 优先级 默认为5
    if (t.getPriority() != priority) {
        t.setPriority(priority);
    }
    return t;
}

protected Thread newThread(Runnable r, String name) {
    return new FastThreadLocalThread(threadGroup, r, name);
}

可以看到创建了一个FastThreadLocalThread类型的线程。FastThreadLocalThread继承自Thread类,看它的两个属性

// 任务执行完,是否清除FastThreadLocal的标记
private final boolean cleanupFastThreadLocals;
// 类似于Thread类中ThreadLocalMap,为了实现FastThreadLocal
private InternalThreadLocalMap threadLocalMap;

说了这么多终于讲到本文的主题,前面所说的这个过程是为了让大家明白EventLoop中的线程都是FastThreadLocalThread类型的。并且在此类型的线程中有一个属性叫做InternalThreadLocalMap,该属性是为了实现FastThreadLocal。

优雅的使用 FastThreadLocal

下面演示两种方式,分别是Netty提供的ThreadFactory和手动创建FastThreadLoalThread。

FastThreadLocal<String> threadLocal = new FastThreadLocal() {
    @Override
    protected String initialValue() throws Exception {
        return "hello netty";
    }

    @Override
    protected void onRemoval(Object value) throws Exception {
        System.out.println("value has be removed");
    }
};

new DefaultThreadFactory("FastThread-Pool")
    .newThread(() -> {
        System.out.println(threadLocal.get());
    }
).start();

new FastThreadLocalThread(() -> {
        threadLocal.set("hello FastThreadLocalThread");
        System.out.println(threadLocal.get());
    }
).start();

/** 输出
hello netty
value has be removed
hello FastThreadLocalThread
value has be removed
*/

首先重写FastThreadLocal的initValue方法很容易理解,和ThreadLocal中的一样,那么重写的onRemoval方法看样子应该是FastThreadLocal移除是会被调用。
在JDK的ThreadLocal中一般我们通过ThreadLocal.remove方法移除一对K/V。在这里似乎当线程把任务执行完毕后会自动的调用类似于remove的方法。
这个逻辑是在创建线程的过程添加进去的,Netty把Runnable的匿名类封装成一个FastThreadLocalRunnable类型,该类的实现如下:

final class FastThreadLocalRunnable implements Runnable {
    private final Runnable runnable;

    private FastThreadLocalRunnable(Runnable runnable) {
        this.runnable = ObjectUtil.checkNotNull(runnable, "runnable");
    }

    @Override
    public void run() {
        try {
            runnable.run();
        } finally {
            // 任务执行完之后,清除当前线程所有FastThreadLocal,removeAll方法中会调用我们实现的onRemoval方法
            FastThreadLocal.removeAll();
        }
    }

    static Runnable wrap(Runnable runnable) {
        return runnable instanceof FastThreadLocalRunnable ? runnable : new FastThreadLocalRunnable(runnable);
    }
}

看到这里就明白了为什么重写的onRemoval方法会被执行了,线程池中的线程由于会被复用,所以线程池中的每一条线程在执行task结束后,
要清理掉其InternalThreadLocalMap和其内的FastThreadLocal信息,否则其InternalThreadLocalMap信息还存储着上一次被使用时的信息;
另外,假设这条线程不再被使用,但是这个线程有可能不会被销毁(与线程池的类型和配置相关),那么其上的ThreadLocal将发生资源泄露。

1. InternalThreadLocalMap 底层数据结构

InternalThreadLocalMap的父类是UnpaddedInternalThreadLocalMap,该类中指定了保存数据的结构。

// SlowMap
static final ThreadLocal<InternalThreadLocalMap> slowThreadLocalMap = new ThreadLocal<InternalThreadLocalMap>();

// FastMap
static final AtomicInteger nextIndex = new AtomicInteger();
Object[] indexedVariables;

有些情况下,我们自己创建的线程并没有使用FastThreadLocalThread,为了适配这种情况,Netty通过Thread原生的ThreadLocal来保存InternalThreadLocalMap。关系图如下:
netty

即Thread中的属性threadLocalMap中key是上面定义的:ThreadLocal<InternalThreadLocalMap> slowThreadLocalMap,注意这是一个静态变量。

如果使用了FastThreadLocalThread,那么存储数据的结构直接使用Netty定义的InternalThreadLocalMap,通过Object[] indexedVariables保存key(FastThreadLocal)和value。nextIndex是一个自增的数组下表。JDK的ThreadLocal是通过Hash计算到下表,遇到冲突通过线性探测法解决。Netty确定了每一个key对应的value在数组中的下标,因此不会有冲突发生。
Netty

下面看一下它的构造方法

private InternalThreadLocalMap() {
  super(newIndexedVariableTable());
}
private static Object[] newIndexedVariableTable() {
	// 创建数据,填充Object对象
    Object[] array = new Object[32];
    Arrays.fill(array, UNSET);
    return array;
}

2. FastThreadLocal

在前面也介绍到FastThreadLocal的用法,和JDK提供的ThreadLcal几乎没出入。下面就一起探索它的内部实现细节。

// 常量0,存放FastThreadLocal集合的下标
private static final int variablesToRemoveIndex = InternalThreadLocalMap.nextVariableIndex();
// 每一个FastThreadLocal对应的Value的下标
private final int index;
private final int cleanerFlagIndex;

构造方法为:

public FastThreadLocal() {
    // 每一个FastThreadLocal对象的index都是不同的,因此确定了 value在数组中的位置
    index = InternalThreadLocalMap.nextVariableIndex();
    // 清除标记位
    cleanerFlagIndex = InternalThreadLocalMap.nextVariableIndex();
}

构造完成之后,进入set和get方法

3. set

set方法的目的是以当前FastThreadLocal为key,设置value到当前FastThreadLocalThread类型线程的 InternalThreadLocalMap实例中。

public final void set(V value) {
    // UNSET为空的Object对象,不允许为空
    if (value != InternalThreadLocalMap.UNSET) {
        InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.get();
        if (setKnownNotUnset(threadLocalMap, value)) {
            registerCleaner(threadLocalMap);
        }
    } else {
        remove();
    }
}

前面说到有两种情况,即线程类型是否为FastThreadLocalThread

  1. 根据不同的线程类型获取不同的InternalThreadLocalMap
  2. 设置value
  3. 注册清理器

下面我们逐一分析:

3.1 获取map

InternalThreadLocalMap.get实现如下:

public static InternalThreadLocalMap get() {
    Thread thread = Thread.currentThread();
    if (thread instanceof FastThreadLocalThread) {
        return fastGet((FastThreadLocalThread) thread);
    } else {
        return slowGet();
    }
}

判断当前线程的类型,如果是FastThreadLocalThread类型,则使用该类内部属性InternalThreadLocalMap,否则使用原生Thread对象中的ThreadLocalMap属性来,然后在此
map中保存key为JDK中的ThreadLocal对象,value为InternalThreadLocalMap(Netty中的类)。

fastGet的逻辑是获取InternalThreadLocalMap,如果不存在那么新创建一个。

private static InternalThreadLocalMap fastGet(FastThreadLocalThread thread) {
    InternalThreadLocalMap threadLocalMap = thread.threadLocalMap();
    if (threadLocalMap == null) {
        // 设置到FastThreadLocalThread对象内部的属性中
        thread.setThreadLocalMap(threadLocalMap = new InternalThreadLocalMap());
    }
    return threadLocalMap;
}

slowGet获取当前线程ThreadLocaMap中key为slowThreadLocalMap(定义声明在UnpaddedInternalThreadLocalMap的常量),value是InternalThreadLocalMap。

private static InternalThreadLocalMap slowGet() {
    ThreadLocal<InternalThreadLocalMap> slowThreadLocalMap = UnpaddedInternalThreadLocalMap.slowThreadLocalMap;
    InternalThreadLocalMap ret = slowThreadLocalMap.get();
    if (ret == null) {
        ret = new InternalThreadLocalMap();
        slowThreadLocalMap.set(ret);
    }
    return ret;
}
3.2 设置value

当 InternalThreadLocalMap.get() 返回了 一个 InternalThreadLocalMap,接下来就可以保存数据了。

private boolean setKnownNotUnset(InternalThreadLocalMap threadLocalMap, V value) {
    // 设置value
    if (threadLocalMap.setIndexedVariable(index, value)) {
        //将key(FastThreadLoca)添加到数组的第一个元素(Set集合)中
        addToVariablesToRemove(threadLocalMap, this);
        return true;
    }
    return false;
}

下面还是逐一分析,分析一下设置value的内部逻辑:

public boolean setIndexedVariable(int index, Object value) {
    // indexedVariables是构造函数中创建的Object数组
    Object[] lookup = indexedVariables;
    // index是从FastThreadLcal中传入的值,初始为1(自增),因为0被静态变量variablesToRemoveIndex抢占了
    if (index < lookup.length) {
        Object oldValue = lookup[index];
        lookup[index] = value;
        return oldValue == UNSET;
    } else {
        expandIndexedVariableTableAndSet(index, value);
        return true;
    }
}

整体逻辑比较直观,如果index没有越界,那么进行覆盖,如果old value为 UNSET,那么返回true,否则返回false。如果越界则进行扩容并返回true。这里有一个小细节。
只有一种情况会返回fasle,即某个元素已经被赋值过了。那么返回false直接影响的是addToVariablesToRemove方法不会执行。即key不会再次被添加到Set集合中。因为
已经被添加过了。下面看一下经典的扩容方式:

private void expandIndexedVariableTableAndSet(int index, Object value) {
    Object[] oldArray = indexedVariables;
    final int oldCapacity = oldArray.length;
    int newCapacity = index;
    newCapacity |= newCapacity >>>  1;
    newCapacity |= newCapacity >>>  2;
    newCapacity |= newCapacity >>>  4;
    newCapacity |= newCapacity >>>  8;
    newCapacity |= newCapacity >>> 16;
    newCapacity ++;

    Object[] newArray = Arrays.copyOf(oldArray, newCapacity);
    Arrays.fill(newArray, oldCapacity, newArray.length, UNSET);
    newArray[index] = value;
    indexedVariables = newArray;
}

这段代码的作用就是按原来的容量扩容2倍。并且保证结果是2的幂次方。JDK中HashMap的扩容也类似。扩容完成之后填充UNSET,并且将保存value。至此保存value的操作已经完毕。
西面分析保存key的过程:

private static void addToVariablesToRemove(InternalThreadLocalMap threadLocalMap, FastThreadLocal<?> variable) {
    // 获取到下表为0的数组元素
    Object v = threadLocalMap.indexedVariable(variablesToRemoveIndex);
    Set<FastThreadLocal<?>> variablesToRemove;
    // 如果未设置过或者为null
    if (v == InternalThreadLocalMap.UNSET || v == null) {
        // 创建一个IdentityHashMap的实现,IdentityHashMap和HashMap类似,只是key的相同判断方式以 ‘==’来决定
        variablesToRemove = Collections.newSetFromMap(new IdentityHashMap<FastThreadLocal<?>, Boolean>());
         // 将这个 Set 放到这个 Map 数组的下标 0 处
        threadLocalMap.setIndexedVariable(variablesToRemoveIndex, variablesToRemove);
    } else {
        // 如果拿到的不是 UNSET ,说明这是第二次操作了,因此可以强转为 Set
        variablesToRemove = (Set<FastThreadLocal<?>>) v;
    }
    // 将 FastThreadLocal 放置到 Set 中
    variablesToRemove.add(variable);
}

这个方法的目的是将一条线程的所有FastThreadLocal对象保存到一个 Set 中,
静态方法 removeAll 就需要使用到这个 Set,可以快速的删除线程 Map 里的所有 FTL 对应的 Value。
如果不使用 Set,那么就需要遍历 InternalThreadLocalMap。

3.3 注册清理器

该方法的作用是将这个 FastThreadLocal注册到一个清理线程中,当 Thread 对象被 gc 的时候,则会自动清理掉FastThreadLocal,防止 JDK 的内存泄漏问题。

private void registerCleaner(final InternalThreadLocalMap threadLocalMap) {
    Thread current = Thread.currentThread();
    // 如果是FastThreadLocalThread类型的线程,都进入此分支。如果他是普通类型的线程,并且注册过了也进入次分支
    // 也就是说不会担心内存泄漏,前面说到过,在Finally块中调用removeAll方法
    if (FastThreadLocalThread.willCleanupFastThreadLocals(current) ||
        threadLocalMap.indexedVariable(cleanerFlagIndex) != InternalThreadLocalMap.UNSET) {
        return;
    }
    // cleanerFlagIndex是构造FastThreadLocal时生成的唯一下标(其实就是value的下标+1)。只有普通的Thread会用到,这个下标用来保存是否被回收
    threadLocalMap.setIndexedVariable(cleanerFlagIndex, Boolean.TRUE);

    ObjectCleaner.register(current, new Runnable() {
        @Override
        public void run() {
            remove(threadLocalMap);
        }
    });
}

注册一个任务,任务的内容就是调用 remove 方法,删除 FastThreadLocal在map中的对象和相应的内容。更深入的内容在后面分析。

总结 FastThreadLocal使用的数组替代JDK中的线性探测发法的Map,如果是Netty内部创建的线程不用担心内存泄漏的,如果开发者使用了普通的线程,
Netty 仍然会借助 JDK 的 ThreadLocal,只是只借用一个槽位,放置 Netty的Map。

4. get

get方法极为简单,实现如下:

public final V get() {
    InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.get();
    Object v = threadLocalMap.indexedVariable(index);
    if (v != InternalThreadLocalMap.UNSET) {
        return (V) v;
    }

    V value = initialize(threadLocalMap);
    registerCleaner(threadLocalMap);
    return value;
}

首先获取当前线程的map,然后根据 FastThreadLocal的index 获取value,然后返回,如果是空对象,
则通过 initialize 返回,initialize 方法会将返回值设置到 map 的槽位中,并放进 Set 中。最后,尝试注册一个清洁器。
我们跟进初始化操作

private V initialize(InternalThreadLocalMap threadLocalMap) {
    V v = null;
    try {
        //1、获取初始值
        v = initialValue();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    // 2、设置value到InternalThreadLocalMap中
    threadLocalMap.setIndexedVariables(index, v);
    // 3、添加当前的FastThreadLocal到InternalThreadLocalMap的Set<FastThreadLocal<?>>中
    addToVariablesToRemove(threadLocalMap, this);

    return v;
}

//初始化参数:由子类复写
protected V initialValue() throws Exception {
    return null;
}

initialize过程和set过程几乎一样,此处不再赘述。

5. remove&Cleaner

5.1 remove

FastThreadLocal有两种删除操作,删除当前线程上的InternalThreadLocalMap中的每一个value以及threadLocalMap本身。单个删除当前的FastThreadLocal对象的值。

public static void removeAll() {
    // 获取到map
    InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.getIfSet();
    if (threadLocalMap == null) {
        return;
    }

    try {
        // 获取到Set<FastThreadLocal>集合
        Object v = threadLocalMap.indexedVariable(variablesToRemoveIndex);
        if (v != null && v != InternalThreadLocalMap.UNSET) {
            @SuppressWarnings("unchecked")
            Set<FastThreadLocal<?>> variablesToRemove = (Set<FastThreadLocal<?>>) v;
            // 将Set转换为数组
            FastThreadLocal<?>[] variablesToRemoveArray =
                    variablesToRemove.toArray(new FastThreadLocal[variablesToRemove.size()]);
            // 遍历数组,删除每一个FastThreadLocal对应的value
            for (FastThreadLocal<?> tlv: variablesToRemoveArray) {
                tlv.remove(threadLocalMap);
            }
        }
    } finally {
        // 删除当前线程的InternalThreadLocalMap
        InternalThreadLocalMap.remove();
    }
}

tlv.remove单个删除过程如下:

private void remove() {
    remove(InternalThreadLocalMap.getIfSet());
}

private void remove(InternalThreadLocalMap threadLocalMap) {
    if (threadLocalMap == null) {
        return;
    }
    // 从 InternalThreadLocalMap 中删除当前的FastThreadLocal对应的value
    Object v = threadLocalMap.removeIndexedVariable(index);
    // 从 InternalThreadLocalMap 中的Set<FastThreadLocal<?>>中删除当前的FastThreadLocal对象
    removeFromVariablesToRemove(threadLocalMap, this);
    // 如果删除的是有效值,则进行onRemove方法的回调
    if (v != InternalThreadLocalMap.UNSET) {
        try {
            // 回调子类复写的onRemoved方法,默认为空实现
            onRemoved((V) v);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

代码非常直观,继续分析删除map的操作

public static void remove() {
    Thread thread = Thread.currentThread();
    if (thread instanceof FastThreadLocalThread) {
         // 将FastThreadLocalThread 内部的map置位null
        ((FastThreadLocalThread) thread).setThreadLocalMap(null);
    } else {
        // 将 ThreadLocal内部ThreadLocalMap 中的value置位null
        slowThreadLocalMap.remove();
    }
}

removeAll操作会在FastThreadLocal线程自动的执行,但是普通类型的线程只能通过手动的remove/removeAll,但是Netty作者提供了另外一个神器ObjectCleaner。
专门对普通线程中FastThreadLocal的回收操作。

5.2 ObjectCleaner

在讲述Netty提供的ObjectCleaner之前需要先了解一下弱引用(WeakRefercence)。

只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中,一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存。不过,由于垃圾回收器是一个优先级很低的线程,因此不一定会很快发现那些只具有弱引用的对象。

使用方式如下:

String str=new String("abc");
WeakReference<String> abcWeakRef = new WeakReference<String>(str);
str=null;

str对象如果被GC发现,则进行回收。

当你想引用一个对象,但是这个对象有自己的生命周期,你不想介入这个对象的生命周期,这时候你就是用弱引用。

弱引用可以和一个引用队列(ReferenceQueue)联合使用,如果弱引用所引用的对象被垃圾回收,Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

我们继续回到ObjectCleaner中,重要的属性如下:

public final class ObjectCleaner {
    private static final int REFERENCE_QUEUE_POLL_TIMEOUT_MS =
            max(500, getInt("io.netty.util.internal.ObjectCleaner.refQueuePollTimeout", 10000));

    // 所有Thread被注册为弱引用的Set集合,因为被多线程共享因此使用ConcurrentSet
    private static final Set<AutomaticCleanerReference> LIVE_SET = new ConcurrentSet<AutomaticCleanerReference>();
    // 被回收的Thread对象的队列(ReferenceQueue),内部有同步机制,不需要担心线程安全问题
    private static final ReferenceQueue<Object> REFERENCE_QUEUE = new ReferenceQueue<Object>();
    // 清理线程的标志
    private static final AtomicBoolean CLEANER_RUNNING = new AtomicBoolean(false);
}

还有一个内部类:

private static final class AutomaticCleanerReference extends WeakReference<Object> {
    private final Runnable cleanupTask;

    AutomaticCleanerReference(Object referent, Runnable cleanupTask) {
        // 这里使用了REFERENCE_QUEUE,即referent被回收后,同时加入到此队列中
        super(referent, REFERENCE_QUEUE);
        this.cleanupTask = cleanupTask;
    }

    void cleanup() {
        cleanupTask.run();
    }
    @Override
    public void clear() {
        LIVE_SET.remove(this);
        super.clear();
    }
}

下面我们看一下前面提到过的注册过程:

public static void register(Object object, Runnable cleanupTask) {
    // 构造一个AutomaticCleanerReference ,Netty内部调用的传参是thread,和remove方法包装的Runnable
    AutomaticCleanerReference reference = new AutomaticCleanerReference(object,
            ObjectUtil.checkNotNull(cleanupTask, "cleanupTask"));
    // 添加到LIVE_SET中
    LIVE_SET.add(reference);

    // 清除线程如果没启动
    if (CLEANER_RUNNING.compareAndSet(false, true)) {
        // 新建一条线程
        final Thread cleanupThread = new FastThreadLocalThread(CLEANER_TASK);
        // 设置低优先级
        cleanupThread.setPriority(Thread.MIN_PRIORITY);
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            @Override
            public Void run() {
                cleanupThread.setContextClassLoader(null);
                return null;
            }
        });
        cleanupThread.setName(CLEANER_THREAD_NAME);
        // 设置为守护线程
        cleanupThread.setDaemon(true);
        cleanupThread.start();
    }
}

注册过程就是将入参object和Runnable包装为一个弱引用对象,然后启动清除线程,继续跟进CLEANER_TASK

private static final Runnable CLEANER_TASK = new Runnable() {
    @Override
    public void run() {
        boolean interrupted = false;
        for (;;) {
            while (!LIVE_SET.isEmpty()) {
                final AutomaticCleanerReference reference;
                try {
                    // 从REFERENCE_QUEUE阻塞获取不强可达的reference,REFERENCE_QUEUE_POLL_TIMEOUT_MS为最大阻塞时间
                    reference = (AutomaticCleanerReference) REFERENCE_QUEUE.remove(REFERENCE_QUEUE_POLL_TIMEOUT_MS);
                } catch (InterruptedException ex) {
                    interrupted = true;
                    continue;
                }
                if (reference != null) {
                    try {
                        // 调用 传入的remove方法
                        reference.cleanup();
                    } catch (Throwable ignored) {
                    }
                    // 从LIVE_SET删除
                    LIVE_SET.remove(reference);
                }
            }
            CLEANER_RUNNING.set(false);
            // 在此检测LIVE_SET
            if (LIVE_SET.isEmpty() || !CLEANER_RUNNING.compareAndSet(false, true)) {
                break;
            }
        }
        if (interrupted) {
            Thread.currentThread().interrupt();
        }
    }
};

总结一下,ObjectCleaner是用来清除SlowThreadLocalMap的,即使用普通线程的情况,在每次使用新的 FastThreadLocal 的时候,将一个弱引用指向当前线程对象。 当这个线程对象被回收的时候,
也会顺便清理掉 FastThreadLocal和它对应的value。

发布了137 篇原创文章 · 获赞 45 · 访问量 6万+

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 像素格子 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览