缓存，有时你必须计算相同的值很多时间，所以通过存储最后一组输入到一个方法和结果，你可以加快代码。通过使用线程本地存储，您可以避免考虑锁定问题。

在Java中，如果您有一个每个线程都可以变化的数据，那么您可以选择将该数据传递给每个需要(或可能需要)它的方法，或者将该数据与线程关联。如果你的所有方法都需要传递一个公共的“上下文”变量，那么到处传递数据可能是可行的。

如果不是这样，您可能不希望用额外的参数来打乱方法签名。在非线程环境中，可以使用Java中等价的全局变量来解决这个问题。在线程词中，与全局变量等价的是线程局部变量。

一种可能的(也是常见的)用途是，当您有一些不是线程安全的对象，但您希望避免同步访问该对象(我正在看您，SimpleDateFormat)。相反，给每个线程它自己的对象实例。

例如:

public class Foo
{
    // SimpleDateFormat is not thread-safe, so give one to each thread
    private static final ThreadLocal<SimpleDateFormat> formatter = new ThreadLocal<SimpleDateFormat>(){
        @Override
        protected SimpleDateFormat initialValue()
        {
            return new SimpleDateFormat("yyyyMMdd HHmm");
        }
    };

    public String formatIt(Date date)
    {
        return formatter.get().format(date);
    }
}

文档。

Many frameworks use ThreadLocals to maintain some context related to the current thread. For example when the current transaction is stored in a ThreadLocal, you don't need to pass it as a parameter through every method call, in case someone down the stack needs access to it. Web applications might store information about the current request and session in a ThreadLocal, so that the application has easy access to them. With Guice you can use ThreadLocals when implementing custom scopes for the injected objects (Guice's default servlet scopes most probably use them as well).

ThreadLocals are one sort of global variables (although slightly less evil because they are restricted to one thread), so you should be careful when using them to avoid unwanted side-effects and memory leaks. Design your APIs so that the ThreadLocal values will always be automatically cleared when they are not needed anymore and that incorrect use of the API won't be possible (for example like this). ThreadLocals can be used to make the code cleaner, and in some rare cases they are the only way to make something work (my current project had two such cases; they are documented here under "Static Fields and Global Variables").

[参考]ThreadLocal无法解决共享对象的更新问题。建议使用staticThreadLocal对象，该对象由同一线程中的所有操作共享。 [必选]remove()方法必须由ThreadLocal变量实现，特别是在使用经常重用线程的线程池时。否则，可能会影响后续的业务逻辑，并导致意想不到的问题，如内存泄漏。

试试这个小例子，感受一下ThreadLocal变量:

public class Book implements Runnable {
    private static final ThreadLocal<List<String>> WORDS = ThreadLocal.withInitial(ArrayList::new);

    private final String bookName; // It is also the thread's name
    private final List<String> words;


    public Book(String bookName, List<String> words) {
        this.bookName = bookName;
        this.words = Collections.unmodifiableList(words);
    }

    public void run() {
        WORDS.get().addAll(words);
        System.out.printf("Result %s: '%s'.%n", bookName, String.join(", ", WORDS.get()));
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(new Book("BookA", Arrays.asList("wordA1", "wordA2", "wordA3")));
        Thread t2 = new Thread(new Book("BookB", Arrays.asList("wordB1", "wordB2")));
        t1.start();
        t2.start();
    }
}

控制台输出，如果线程BookA先执行: 结果BookA: 'wordA1, wordA2, wordA3'。 结果BookB: 'wordB1, wordB2'。 控制台输出，如果先执行线程BookB: 结果BookB: 'wordB1, wordB2'。 结果BookA: 'wordA1, wordA2, wordA3'。