自己手动实现的 TransmittableThreadLocal

勒农ng

已于 2023-12-05 15:02:02 修改

阅读量66

点赞数

文章标签： java 开发语言

于 2023-12-05 11:30:44 首次发布

本文链接：https://blog.csdn.net/m0_37651658/article/details/134801290

版权

本文只是为了实现功能, 没有考虑内存泄漏.

InheritableThreadLocal的问题

1. 线程池和ForkJoin线程池的复用问题: 线程池里的线程只会保存新建该线程时的父线程的临时状态, 此后父线程使用InheritableThreadLocal再设置新值, 复用的线程无法感知到变化,无法将新值传递给子线程.

TransmittableThreadLocal如何解决这个问题:

1. 使用 InheritableThreadLocal<HashMap<MySelfThreadLocal<Object>,Object>>

来保存线程的ThreadLocal的使用状态 (重写set,get,remove方法实现)

1. 父线程t1使用了 a和b的ThreadLocal

2. 子线程s1使用了 b和c的ThreadLocal

此时t1线程的InheritableThreadLocal会保存一个Map, 存储{a=null,b=null}, 并将这个Map塞入InheritableThreadLocal. 只有t1可以获取到这个Map. 同理s1存储的是{b=null,c=null}.

2. 重写Runnable.

1. 在新建Runnable时根据InheritableThreadLocal可以获取到父线程使用了哪些threadLocal, 并使用ThreadLocal.get()获取具体的值, 使用一个 HashMap<MySelfThreadLocal<Object>, Object> 保存父线程的threadLocal现场.

2. 在Runnable的run方法内部, 同样使用一个新的HashMap<MySelfThreadLocal<Object>, Object>来保存子线程的threadLocal现场.

3. 将父线程的ThreadLocal现场设置给子线程.

4. 调用原先的Runnable的run方法

5. 将子线程的现场还原, 注意将子环境新的ThreadLocal删除. (线程池存在CallerRunsPolicy, ForkJoin线程池会存在主线程执行任务的情况)

3. 为什么最后还要还原子线程的线程呢?

1. 线程池存在CallerRunsPolicy, 主线程会执行Runnable, 有可能会被Runnable内的新建的ThreadLocal污染.

2. ForkJoin线程池会存在主线程执行任务的情况.

package com.gaotu.maven_first.thread;

import com.alibaba.ttl.TransmittableThreadLocal;
import com.alibaba.ttl.TtlRunnable;
import lombok.extern.slf4j.Slf4j;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * @author: zhangzeling
 * @date: 2023/12/4
 * @description: MySelfThreadLocal
 * <p>
 * 自己手动实现的 TransmittableThreadLocal
 */
@Slf4j
public class MySelfThreadLocal<T> extends InheritableThreadLocal<T> {
    /**
     * 保存每个线程使用ThreadLocal的情况, 保存哪个线程用了哪些ThreadLocal
     */
    private static InheritableThreadLocal<Map<MySelfThreadLocal<Object>, Object>> map = new InheritableThreadLocal<Map<MySelfThreadLocal<Object>, Object>>() {
        // 初始化值
        @Override
        protected Map<MySelfThreadLocal<Object>, Object> initialValue() {
            return new WeakHashMap<>();
        }

        // 继承父线程的值
        @Override
        protected Map<MySelfThreadLocal<Object>, Object> childValue(Map<MySelfThreadLocal<Object>, Object> parentValue) {
            return new WeakHashMap<>(parentValue);
        }
    };


    public static void main(String[] args) {
        AtomicInteger order = new AtomicInteger(1);
        ExecutorService executorService = new ThreadPoolExecutor(0, 1, 1, TimeUnit.SECONDS, new SynchronousQueue<>(), new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r, String.format("%s-%s", "test", order.getAndIncrement()));
                thread.setDaemon(true);
                return thread;
            }
        }, new ThreadPoolExecutor.CallerRunsPolicy());

        // 子环境删除的
        MySelfThreadLocal<String> removeThreadLocal = new MySelfThreadLocal<>();
        // 主环境不设置值的
        MySelfThreadLocal<String> noSetThreadLocal = new MySelfThreadLocal<>();
        // 子环境添加的
        MySelfThreadLocal<String> slaveAdd = new MySelfThreadLocal<>();
        // 主环境删除的
        MySelfThreadLocal<String> mainDel = new MySelfThreadLocal<>();

        for (int i = 0; i < 10; i++) {
            removeThreadLocal.set("removeThreadLocal" + i);
            int finalI = i;
            TestRunnable inheritableTask = TestRunnable.get(() -> {
                log.info("removeThreadLocal pre: {}", removeThreadLocal.get());
                removeThreadLocal.set(Thread.currentThread().getName());
                removeThreadLocal.remove();
                noSetThreadLocal.set("noSetThreadLocal" + finalI);
            });
            executorService.submit(inheritableTask);
            log.info("removeThreadLocal last: {}", removeThreadLocal.get());
            log.info("noSetThreadLocal:last {}", noSetThreadLocal.get());

        }
        for (int i = 0; i < 10; i++) {
            int finalI = i;
            TestRunnable inheritableTask = TestRunnable.get(() -> {
                log.info("slaveAdd {} pre: {}", finalI, slaveAdd.get());
                slaveAdd.set(Thread.currentThread().getName());
                log.info("slaveAdd {} mid:{}", finalI, slaveAdd.get());
            });
            log.info("slaveAdd {} last:{}", i, slaveAdd.get());
            executorService.submit(inheritableTask);
        }

        for (int i = 0; i < 10; i++) {
            mainDel.set("mainDel" + i);
            int finalI = i;
            TestRunnable inheritableTask = TestRunnable.get(() -> {
                log.info("mainDel {} pre: {}", finalI, mainDel.get());
                mainDel.remove();
                log.info("mainDel {} mid:{}", finalI, mainDel.get());
            });
            log.info("mainDel pre {} last:{}", i, mainDel.get());
            mainDel.remove();
            log.info("mainDel last {} last:{}", i, mainDel.get());
            executorService.submit(inheritableTask);
        }
        executorService.shutdown();
        // 测试和TransmittableThreadLocal的耗时  删除原先测试的MySelfThreadLocal
        Map<MySelfThreadLocal<Object>, Object> mySelfThreadLocalObjectMap = map.get();
        Iterator<MySelfThreadLocal<Object>> iterator = new HashSet<>(mySelfThreadLocalObjectMap.keySet()).iterator();
        while (iterator.hasNext()) {
            MySelfThreadLocal<Object> next = iterator.next();
            next.remove();
        }
        int total = 10000;
        testTimeConsume(Executors.newFixedThreadPool(10), MySelfThreadLocal::new, TestRunnable::get, total);
        testTimeConsume(Executors.newFixedThreadPool(10), TransmittableThreadLocal::new, TtlRunnable::get, total);


    }

    public static void testTimeConsume(ExecutorService executorService, Supplier<InheritableThreadLocal<String>> supplier, Function<Runnable, Runnable> function, int total) {
        // 测试耗时
        Runnable r = () -> {
        };
        for (int i = 0; i < total; i++) {
            InheritableThreadLocal<String> objectMySelfThreadLocal = supplier.get();
            objectMySelfThreadLocal.set("a");
        }
        long t3 = System.currentTimeMillis();
        for (int i = 0; i < total; i++) {
            executorService.submit(function.apply(r));
        }
        long t4 = System.currentTimeMillis();
        log.info("总数为:{}的额外耗时为:{}", total, t4 - t3);
        executorService.shutdown();
    }


    @Override
    public void set(T value) {

        super.set(value);
        Map<MySelfThreadLocal<Object>, Object> mySelfThreadLocalObjectHashMap = map.get();
        if (!mySelfThreadLocalObjectHashMap.containsKey(this)) {
            mySelfThreadLocalObjectHashMap.put((MySelfThreadLocal<Object>) this, null);
        }
    }

    @Override
    public T get() {
        T t = super.get();
        Map<MySelfThreadLocal<Object>, Object> mySelfThreadLocalObjectHashMap = map.get();
        if (!mySelfThreadLocalObjectHashMap.containsKey(this)) {
            mySelfThreadLocalObjectHashMap.put((MySelfThreadLocal<Object>) this, null);
        }
        return t;
    }

    @Override
    public void remove() {
        Map<MySelfThreadLocal<Object>, Object> mySelfThreadLocalObjectHashMap = map.get();
        mySelfThreadLocalObjectHashMap.remove(this);
        super.remove();
    }

    static class TestRunnable implements Runnable {

        private AtomicReference<Map<MySelfThreadLocal<Object>, Object>> mainThreadLocalReference = new AtomicReference<>(save(map.get()));
        private Runnable runnable;

        private TestRunnable(Runnable r) {
            this.runnable = r;
        }


        private static Map<MySelfThreadLocal<Object>, Object> save(Map<MySelfThreadLocal<Object>, Object> holder) {
            Iterator<MySelfThreadLocal<Object>> iterator = holder.keySet().iterator();
            Map<MySelfThreadLocal<Object>, Object> preHolder = new WeakHashMap<>();
            while (iterator.hasNext()) {
                MySelfThreadLocal<Object> next = iterator.next();
                Object value = next.get();
                if (value != null) {
                    // 保存现场的时候 有可能从线程设置了新的ThreadLocal  但是父线程没有设置, 那么父线程保存环境时要把这种情况排除(线程池的CallerRunsPolicy)
                    preHolder.put(next, value);
                }
            }
            return preHolder;
        }


        private static void set(Map<MySelfThreadLocal<Object>, Object> preHolder) {
            Iterator<MySelfThreadLocal<Object>> iterator = preHolder.keySet().iterator();
            while (iterator.hasNext()) {
                MySelfThreadLocal<Object> next = iterator.next();
                Object value = preHolder.get(next);
                next.set(value);
            }
        }

        private static void del(Map<MySelfThreadLocal<Object>, Object> holder, Map<MySelfThreadLocal<Object>, Object> preHolder) {
            Iterator<MySelfThreadLocal<Object>> iterator = holder.keySet().iterator();
            while (iterator.hasNext()) {
                MySelfThreadLocal<Object> next = iterator.next();
                if (!preHolder.containsKey(next)) {
                    next.remove();
                }
            }
        }

        /**
         * 最关键的获取包装后的Runnable
         *
         * @param runnable
         * @return
         */
        public static TestRunnable get(Runnable runnable) {
            return new TestRunnable(runnable);
        }

        @Override
        @SuppressWarnings("unchecked")
        public void run() {
            // 保护从环境的值
            Map<MySelfThreadLocal<Object>, Object> pre = save(map.get());

            // 设置主环境值, 要将主环境的所有的ThreadLocal全部设置进去
            Map<MySelfThreadLocal<Object>, Object> mainHolder = mainThreadLocalReference.get();
            set(mainHolder);

            // 执行 runable
            runnable.run();
            // 设置从环境值,
            set(pre);
            // 要删除从环境设置的新的ThreadLocal
            del(map.get(), pre);
        }
    }

}