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

Question

用例

我有一个基于gRPC Guice的服务应用程序，其中对于特定的调用，代码流如下所示：a-

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

我希望在这些类的B、C和Y类之间有一个共享对象ContainerDoc，但不希望传递给方法参数。因此，我决定使用InheritableThreadLocal。

但我想了解如何强制将父线程本地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（）实现与默认值完全相同。

当创建一个新线程时，将根据父线程为In遗产线程本地分配一个值。ExecutorService可以有任何实现，并且您没有指定如何创建线程，但是对于您的工作方法，父线程需要设置值，创建一个新线程，然后使用该新线程执行任务。换句话说，它只能工作于非池线程。

Threadlocal是解决第三方代码中无法更改的设计缺陷的笨拙方法。即使它起作用了，这也是最后的手段——在这里，它不起作用。

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

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