如何与子线程共享父 ThreadLocal 对象引用？

Question

用例

我有一个基于 gRPC+Guice 的服务应用程序，其中对于特定调用，代码流如下所示：A -> B -> C 和 A -> X -> Y 对于特定服务请求。

其中，A = 顶级服务操作/Activity 类； B = 以 C 类作为任务创建 ExecutorService 线程池的类； X 和 Y 是普通类。

我想要一个跨类 B、C 和 Y 这些类的共享对象 ContainerDoc，但不想传递给方法参数。所以，我决定使用 InheritableThreadLocal。

但我想了解如何强制将父 ThreadLocal ContainerDoc 共享给子线程，以便子线程在 ContainerDoc 中完成的任何 更新 对父线程也可见？

1. 重写 childValue 方法 是否返回与父对象相同的包含对象以使其工作？ （见下文实施）。
2. 如何确保线程安全？

示例实施

class ContainerDoc implements ServiceDoc {
    private final Map < KeyEnum, Object > containerMap;

    public ContainerDoc() {
        this.containerMap = new HashMap < KeyEnum, Object > ();
        // Should it be ConcurrentHashmap to account for concurrent updates?
    }

    public < T > T getEntity(final KeyEnum keyEnum) {
        return (T) containerMap.get(keyEnum);
    }

    public void putEntity(final KeyEnum keyEnum, final Object value) {
        entities.put(keyEnum, value);
    }

    enum KeyEnum {
        Key_A,
        Key_B;
    }

}

public enum MyThreadLocalInfo {

    THREADLOCAL_ABC(ContainerDoc.class, new InheritableThreadLocal < ServiceDoc > () {

            // Sets the initial value to an empty class instance.
            @Override
            protected ServiceContext initialValue() {
                return new ContainerDoc();
            }

            // Just for reference. The below impl shows default 
            // behavior. This method is invoked when any new
            // thread is created from a parent thread.
            // This ensures every child thread will have same 
            // reference as parent.
            @Override
            protected ServiceContext childValue(final ServiceDoc parentValue) {
                return parentValue;
                // Returning same reference but I think this 
                // value gets copied over to each Child thread as 
                // separate object instead of reusing the same 
                // copy for thread-safety. So, how to ensure 
                // using the same reference as of parent thread?
            }
        }),
        THREADLOCAL_XYZ(ABC.class, new InheritableThreadLocal < ServiceDoc > () {
            ....
            ....
        });

    private final Class << ? extends ServiceDoc > contextClazz;

    private final InheritableThreadLocal < ServiceDoc > threadLocal;

    MyThreadLocalInfo(final Class << ? extends ServiceDoc > contextClazz,
        final InheritableThreadLocal < ServiceDoc > threadLocal) {
        this.contextClazz = contextClazz;
        this.threadLocal = threadLocal;
    }

    public ServiceDoc getDoc() {
        return threadLocal.get();
    }

    public void setDoc(final ServiceDoc serviceDoc) {
        Validate.isTrue(contextClazz.isAssignableFrom(serviceDoc.getClass()));
        threadLocal.set(serviceDoc);
    }

    public void clearDoc() {
        threadLocal.remove();
    }
}

客户端代码（来自子线程类或常规类

MyThreadLocalInfo.THREADLOCAL_ABC.setDoc(new ContainerDoc());
MyThreadLocalInfo.THREADLOCAL_ABC.getDoc().put(Key_A, new Object());
MyThreadLocalInfo.THREADLOCAL_ABC.clearDoc();

Answer 1

返回相同的引用 但我认为这个值会作为单独的对象复制到每个子线程中

运行时如何实例化这样一个“单独的对象”？这个理论是不正确的。您的childValue() 实现与默认实现完全相同。

InheritableThreadLocal 在创建新线程时根据父级分配一个值。ExecutorService 可以有任何实现，您无需指定您的线程如何创建，但对于您的工作方法，父线程需要设置值，创建一个新线程，然后使用该新线程执行任务。换句话说，它只能与未池化的线程一起使用。

ThreadLocal 是解决第三方代码中无法更改的设计缺陷的工具。即使它有效，它也是最后的手段——而在这里，它不起作用。

将ServiceDoc 作为必要的方法或构造函数参数传递给 B、C 和 Y。

这可能意味着 X 也需要传递 ServiceDoc，但是，由于 X-Y 代码路径中不涉及 Executor，因此 A 可以在调用 X 之前有条件地初始化 ThreadLocal。这可能更丑陋而不是将其作为参数传递。