FastThreadLocal

ThreadLocal

使用场景

使用场景是在于同一个类，但是会开多个线程执行，但是每一个线程可以保持不同的变量状态。

做法如上图，线程类Thread有成员变量ThreadLocal.ThreadLocalMap,用来存储该线程中的所有的ThreadLocal变量，初始化是一个Entry数组。

内存泄漏

static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }

Entry继承于WeakReference，简单说一下四种引用。强引用，就是我们常规使用的new出来一个对象，这时候会有变量建立具体的对象联系。软引用，适用于cache类型的变量，当jvm内存不够时会释放该引用。弱引用，只要发生gc就会回收。虚引用，没有很深刻的体会。

 SoftReference<Dog> softReference = new SoftReference<Dog>(new Dog("dd"));

        while (true){
            if(softReference.get() == null){
                System.out.println("null");
                break;
            }else {
                System.out.println("ok");
            }
            System.gc();
        }

ok
ok
ok
...

WeakReference<Dog> weakReference = new WeakReference<Dog>(new Dog("dd"));

        while (true){
            if(weakReference.get() == null){
                System.out.println("null");
                break;
            }else {
                System.out.println("ok");
            }
            System.gc();
        }
ok
null

Entry中的key设置为虚引用，那么gc时候会被回收，此时ThreadLocal进行清理的时候可以根据key是否为null进行判断清除，防止内存泄漏。

但是还是要调用remove函数，这个在线程池中如果不执行的话会造成内存泄漏，因为线程不进行回收，那么ThreadLocalMap中会一直存在这些Entry，同时不进行remove的话就会一直占用内存。

Hash原理

获取线程对应的ThreadLocal，是应用hashcode在Map中定位，如果发生hash冲突使用的是线性寻地址法，即往下一位找，这种冲突方法有概率会导致死循环。所以如果变量过多，冲突很多，定位较慢。

private Entry getEntry(ThreadLocal<?> key) {
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, e);
        }
 private void set(ThreadLocal<?> key, Object value) {

            // We don't use a fast path as with get() because it is at
            // least as common to use set() to create new entries as
            // it is to replace existing ones, in which case, a fast
            // path would fail more often than not.

            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);

            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();

                if (k == key) {
                    e.value = value;
                    return;
                }

                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

FastThreadLocal

使用场景

不同于JDK自带的ThreadLocal，如果Thread是使用的FastThreadLocalThread，那么自带有private InternalThreadLocalMap threadLocalMap，那么如果类中有用到FastThreadLocal会从threadLocalMap中获取，netty中每一个FastThreadLocal都有全局唯一的index，所以是常数级从数组中定位获取内容，并且在set的同时会将该FastThreadLocal放到threadLocalMap中index为0的Set<FastThreadLocal<?>>上，这样垃圾清理会比较简单和快捷。

构造函数

   public FastThreadLocal() {
        index = InternalThreadLocalMap.nextVariableIndex();
        cleanerFlagIndex = InternalThreadLocalMap.nextVariableIndex();
    }

由该函数保证了index的全局唯一性

    public static int nextVariableIndex() {
        int index = nextIndex.getAndIncrement();
        if (index < 0) {
            nextIndex.decrementAndGet();
            throw new IllegalStateException("too many thread-local indexed variables");
        }
        return index;
    }

set方法

    public final void set(V value) {
        // 如果设置的非“空”
        if (value != InternalThreadLocalMap.UNSET) {
            // 获取存储的Map对象
            InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.get();
            // 如果当前设置的index上是unset（即我们已经开始污染使用这个Map了），进行注册清理操作（保证内存清理）
            if (setKnownNotUnset(threadLocalMap, value)) {
                registerCleaner(threadLocalMap);
            }
        } else {
            // 如果设置UNSET，则进行清理操作
            remove();
        }
    }

UNSET是一个new Object()对象，一方面用来填充整个空的Map，另一方面也是一个判断是否使用的标志。

    public static InternalThreadLocalMap get() {
        Thread thread = Thread.currentThread();
        if (thread instanceof FastThreadLocalThread) {
            // 直接会从FastThreadLocalThread中的成员变量中获取InternalThreadLocalMap
            return fastGet((FastThreadLocalThread) thread);
        } else {
            // ThreadLocal<InternalThreadLocalMap>，用JDK的ThreadLocal代存InternalThreadLocalMap
            return slowGet();
        }
    }

  private boolean setKnownNotUnset(InternalThreadLocalMap threadLocalMap, V value) {
        // 数组定位进行替换，判断原来的位置是否没用过，即是否为unset
        if (threadLocalMap.setIndexedVariable(index, value)) {
            // 存放到数组[0]上的set中，方便回收
            addToVariablesToRemove(threadLocalMap, this);
            return true;
        }
        return false;
    }

    public boolean setIndexedVariable(int index, Object value) {
        Object[] lookup = indexedVariables;
        if (index < lookup.length) {
            Object oldValue = lookup[index];
            lookup[index] = value;
            return oldValue == UNSET;
        } else {
            expandIndexedVariableTableAndSet(index, value);
            return true;
        }
    }

    private static void addToVariablesToRemove(InternalThreadLocalMap threadLocalMap, FastThreadLocal<?> variable) {
        Object v = threadLocalMap.indexedVariable(variablesToRemoveIndex);
        Set<FastThreadLocal<?>> variablesToRemove;
        // 判断v有没有设置为set，一般是首次会执行这个
        if (v == InternalThreadLocalMap.UNSET || v == null) {
            variablesToRemove = Collections.newSetFromMap(new IdentityHashMap<FastThreadLocal<?>, Boolean>());
            threadLocalMap.setIndexedVariable(variablesToRemoveIndex, variablesToRemove);
        } else {
            // 已经设置过了
            variablesToRemove = (Set<FastThreadLocal<?>>) v;
        }
        // 直接在set中加入当前的FastThreadLocal
        variablesToRemove.add(variable);
    }

注册到ObjectClean中，保证会被清理内存

    private void registerCleaner(final InternalThreadLocalMap threadLocalMap) {
        Thread current = Thread.currentThread();
        if (FastThreadLocalThread.willCleanupFastThreadLocals(current) ||
            threadLocalMap.indexedVariable(cleanerFlagIndex) != InternalThreadLocalMap.UNSET) {
            return;
        }
        // removeIndexedVariable(cleanerFlagIndex) isn't necessary because the finally cleanup is tied to the lifetime
        // of the thread, and this Object will be discarded if the associated thread is GCed.
        threadLocalMap.setIndexedVariable(cleanerFlagIndex, Boolean.TRUE);

        // We will need to ensure we will trigger remove(InternalThreadLocalMap) so everything will be released
        // and FastThreadLocal.onRemoval(...) will be called.
        ObjectCleaner.register(current, new Runnable() {
            @Override
            public void run() {
                remove(threadLocalMap);

                // It's fine to not call InternalThreadLocalMap.remove() here as this will only be triggered once
                // the Thread is collected by GC. In this case the ThreadLocal will be gone away already.
            }
        });
    }

ObjectCleaner

这个和ThreadDeathWatcher的监控大致原理是相似的，都是开启一个监控守护线程进行for循环拉取任务，只是该类没有取消任务，所以直接一个并发安全的set就足够。

注册函数将需要进行清理的object对象设为虚引用，并保存了清理任务，放入到任务集中，如果未开启监控线程就开启。

监控线程死循环拿出虚引用队列，如果有引用拿到，说明该对象已经被gc，此时执行清理任务，如果无任务了就关闭线程。反之继续。

这么做能保证内存释放，即使是使用JDK的ThreadLocal，因为也是对象Map。

/**
 * Allows a way to register some {@link Runnable} that will executed once there are no references to an {@link Object}
 * anymore.
 */
public final class eObjectCleaner {
    private static final int REFERENCE_QUEUE_POLL_TIMEOUT_MS =
            max(500, getInt("io.netty.util.internal.ObjectCleaner.refQueuePollTimeout", 10000));

    // Package-private for testing
    static final String CLEANER_THREAD_NAME = ObjectCleaner.class.getSimpleName() + "Thread";
    // This will hold a reference to the AutomaticCleanerReference which will be removed once we called cleanup()
    private static final Set<AutomaticCleanerReference> LIVE_SET = new ConcurrentSet<AutomaticCleanerReference>();
    private static final ReferenceQueue<Object> REFERENCE_QUEUE = new ReferenceQueue<Object>();
    private static final AtomicBoolean CLEANER_RUNNING = new AtomicBoolean(false);
    private static final Runnable CLEANER_TASK = new Runnable() {
        @Override
        public void run() {
            boolean interrupted = false;
            for (;;) {
                // Keep on processing as long as the LIVE_SET is not empty and once it becomes empty
                // See if we can let this thread complete.
                while (!LIVE_SET.isEmpty()) {
                    final AutomaticCleanerReference reference;
                    try {
                        // 从虚引用的队列中获取引用，这个是只有对象被回收才会放到这个队列中，能获取得到，说明该引用已经被gc
                        reference = (AutomaticCleanerReference) REFERENCE_QUEUE.remove(REFERENCE_QUEUE_POLL_TIMEOUT_MS);
                    } catch (InterruptedException ex) {
                        // Just consume and move on
                        interrupted = true;
                        continue;
                    }
                    if (reference != null) {
                        try {
                            // 执行引用的清理任务，从而保证gc后也能清理
                            reference.cleanup();
                        } catch (Throwable ignored) {
                            // ignore exceptions, and don't log in case the logger throws an exception, blocks, or has
                            // other unexpected side effects.
                        }
                        // 从任务集中去除引用
                        LIVE_SET.remove(reference);
                    }
                }
                CLEANER_RUNNING.set(false);

                // Its important to first access the LIVE_SET and then CLEANER_RUNNING to ensure correct
                // behavior in multi-threaded environments.
                if (LIVE_SET.isEmpty() || !CLEANER_RUNNING.compareAndSet(false, true)) {
                    // There was nothing added after we set STARTED to false or some other cleanup Thread
                    // was started already so its safe to let this Thread complete now.
                    break;
                }
            }
            if (interrupted) {
                // As we caught the InterruptedException above we should mark the Thread as interrupted.
                Thread.currentThread().interrupt();
            }
        }
    };

    /**
     * Register the given {@link Object} for which the {@link Runnable} will be executed once there are no references
     * to the object anymore.
     *
     * This should only be used if there are no other ways to execute some cleanup once the Object is not reachable
     * anymore because it is not a cheap way to handle the cleanup.
     */
    public static void register(Object object, Runnable cleanupTask) {
        AutomaticCleanerReference reference = new AutomaticCleanerReference(object,
                ObjectUtil.checkNotNull(cleanupTask, "cleanupTask"));
        // Its important to add the reference to the LIVE_SET before we access CLEANER_RUNNING to ensure correct
        // behavior in multi-threaded environments.
        // 任务集内容，要保证并发安全
        LIVE_SET.add(reference);

        // Check if there is already a cleaner running.
        // 如果running标志没开启，CAS操作进行开启一个守护线程执行
        if (CLEANER_RUNNING.compareAndSet(false, true)) {
            final Thread cleanupThread = new FastThreadLocalThread(CLEANER_TASK);
            cleanupThread.setPriority(Thread.MIN_PRIORITY);
            // Set to null to ensure we not create classloader leaks by holding a strong reference to the inherited
            // classloader.
            // See:
            // - https://github.com/netty/netty/issues/7290
            // - https://bugs.openjdk.java.net/browse/JDK-7008595
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                @Override
                public Void run() {
                    cleanupThread.setContextClassLoader(null);
                    return null;
                }
            });
            cleanupThread.setName(CLEANER_THREAD_NAME);

            // Mark this as a daemon thread to ensure that we the JVM can exit if this is the only thread that is
            // running.
            cleanupThread.setDaemon(true);
            cleanupThread.start();
        }
    }

    public static int getLiveSetCount() {
        return LIVE_SET.size();
    }

    private ObjectCleaner() {
        // Only contains a static method.
    }

    // 继承软引用，这里Object是thread，用来判断thread是否被回收
    private static final class AutomaticCleanerReference extends WeakReference<Object> {
        // 存下任务
        private final Runnable cleanupTask;

        AutomaticCleanerReference(Object referent, Runnable cleanupTask) {
            super(referent, REFERENCE_QUEUE);
            this.cleanupTask = cleanupTask;
        }

        void cleanup() {
            cleanupTask.run();
        }

        @Override
        public Thread get() {
            return null;
        }

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

remove方法

    public final void remove(InternalThreadLocalMap threadLocalMap) {
        if (threadLocalMap == null) {
            return;
        }
        // lookup[index] = UNSET;制定位置置为unset，去除value强引用
        Object v = threadLocalMap.removeIndexedVariable(index);
        // set.remove(this)，去除FastTheadLocal的强引用
        removeFromVariablesToRemove(threadLocalMap, this);

        if (v != InternalThreadLocalMap.UNSET) {
            try {
                // 可以重写，做一些自己想做的事情。。
                onRemoval((V) v);
            } catch (Exception e) {
                PlatformDependent.throwException(e);
            }
        }
    }

  // 从set中取出所有的FastThreadLocal执行remove，并且最后将Map置为空，all over
   public static void removeAll() {
        InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.getIfSet();
        if (threadLocalMap == null) {
            return;
        }

        try {
            Object v = threadLocalMap.indexedVariable(variablesToRemoveIndex);
            if (v != null && v != InternalThreadLocalMap.UNSET) {
                @SuppressWarnings("unchecked")
                Set<FastThreadLocal<?>> variablesToRemove = (Set<FastThreadLocal<?>>) v;
                FastThreadLocal<?>[] variablesToRemoveArray =
                        variablesToRemove.toArray(new FastThreadLocal[variablesToRemove.size()]);
                for (FastThreadLocal<?> tlv: variablesToRemoveArray) {
                    tlv.remove(threadLocalMap);
                }
            }
        } finally {
            InternalThreadLocalMap.remove();
        }
    }

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;
    }

对比

• 都是Thead自己存储自己的TheadLocal
• JDK的存储使用线性探测法的Map，数量大容易造成冲突，性能下降很快，并且会有内存泄漏的风险。
• FastTheadLocal快的原因改进了存储方式，全局唯一index来标志一个ftl，当然这样如果全局ftl很多会造成空间浪费，这是一种空间换时间的方式。同时它会进行内存监控清理防止内存泄漏。
• 个人认为在TheadLocal不多的情况下其实两种性能差不多（因为JDK自身不会hash冲突），但是Ftl更能保证内存不泄漏，所以JDK调用的时候记得remove

reference

https://www.jianshu.com/p/3fc2fbac4bb7

转载于:https://www.cnblogs.com/GrimReaper/p/10385325.html