在Java中使用ThreadLocal的良好实践(Good Practice of using ThreadLocal in Java)

 我有一个关于如何使用ThreadLocal 。 
 
 背景和情况 
 
 有几个单独的对象使用ThreadLocal为每个线程创建一个副本。 这个单例对象有一个函数foo() 。 
 
public class SingletonA {
    protected static ThreadLocal<SingletonA> singleton = new ThreadLocal<SingletonA>() {
        @Override
        protected SingletonA initialValue() {
            return new SingletonA();
        }
    };

    private SingletonA() { ... }
    public static SingletonA getInstance() { return singleton.get(); }
    public static void remove() { singleton.remove(); }
    public static void foo() { ... }
}
 
 ...有SingletonB，SingletonC等等。 
 
 有一个单例存储库可以缓存上面的ThreadLocal单例。 这个类也是一个ThreadLocal单例 - 
 
public class SingletonRepo {
        protected static ThreadLocal<SingletonRepo> singleton = new ThreadLocal<SingletonRepo>() {
        @Override
        protected SingletonRepo initialValue() {
            return new SingletonRepo();
        }
    };

    private SingletonRepo() { ... }
    public static SingletonRepo getInstance() { return singleton.get(); }
    public static void remove() { singleton.remove(); }

    public SingletonA singletonA;
    // same thing for singletonB, singletonC, ...

   public static init() {
        // Caching the ThreadLocal singleton
        singletonA = SingletonA.getInstance();
        // Same thing for singletonB, singletonC ...
   }
}
 
 这是我目前通过SingletonRepo访问ThreadLocal单SingletonRepo 
 
public class App {
    public SingletonRepo singletonRepo;
    public static void main(String [] args) {
        singletonRepo = SingletonRepo.getInstance();
        singletonRepo.init();

        singletonRepo.singletonA.helperFunction();
    }
}
 
 题 
 
 正如您在上面的上下文中看到的，为了访问ThreadLocal单例，我首先在SingletonRepo缓存它们。 当我需要使用ThreadLocal单例时，我从缓存引用中获取它。 我有以下问题 - 
 
 
 
 通过缓存副本访问ThreadLocal单例是不好的做法吗？ 
 
 
 总是通过SingletonA.getInstance() （为Singleton对象调用get()访问ThreadLocal单例是一种更好的做法吗？ 
 

I have a question regarding to how I should use ThreadLocal.
 
Context and Situation
 
There are several singleton objects that use ThreadLocal to create one copy per thread. This singleton object has a function foo().
 
public class SingletonA {
    protected static ThreadLocal<SingletonA> singleton = new ThreadLocal<SingletonA>() {
        @Override
        protected SingletonA initialValue() {
            return new SingletonA();
        }
    };

    private SingletonA() { ... }
    public static SingletonA getInstance() { return singleton.get(); }
    public static void remove() { singleton.remove(); }
    public static void foo() { ... }
}
 
... There are SingletonB, SingletonC, and so forth.
 
There is a singleton repository that caches the ThreadLocal singletons above. This class is also a ThreadLocal singleton -
 
public class SingletonRepo {
        protected static ThreadLocal<SingletonRepo> singleton = new ThreadLocal<SingletonRepo>() {
        @Override
        protected SingletonRepo initialValue() {
            return new SingletonRepo();
        }
    };

    private SingletonRepo() { ... }
    public static SingletonRepo getInstance() { return singleton.get(); }
    public static void remove() { singleton.remove(); }

    public SingletonA singletonA;
    // same thing for singletonB, singletonC, ...

   public static init() {
        // Caching the ThreadLocal singleton
        singletonA = SingletonA.getInstance();
        // Same thing for singletonB, singletonC ...
   }
}
 
This is currently how I access the ThreadLocal singletons through SingletonRepo
 
public class App {
    public SingletonRepo singletonRepo;
    public static void main(String [] args) {
        singletonRepo = SingletonRepo.getInstance();
        singletonRepo.init();

        singletonRepo.singletonA.helperFunction();
    }
}
 
Question
 
As you have seen in the context above, in order to access the ThreadLocal singletons, I first cached them in the SingletonRepo. When I need to use the ThreadLocal singleton, I get it from the cache reference. I have the following questions -
 
 
 
Is it a bad practice to access the ThreadLocal singleton through a cache copy?
 
 
Is it a better practice to always access the ThreadLocal singleton through SingletonA.getInstance() (Calling get() for the Singleton object)?
 

原文：https://stackoverflow.com/questions/27536194