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

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

可以使用threadlocal变量的两个用例- 1-当我们需要将状态与线程关联时(例如，用户ID或事务ID)。这通常发生在web应用程序中，每个发送到servlet的请求都有一个与之关联的唯一transactionID。

// This class will provide a thread local variable which
// will provide a unique ID for each thread
class ThreadId {
    // Atomic integer containing the next thread ID to be assigned
    private static final AtomicInteger nextId = new AtomicInteger(0);

    // Thread local variable containing each thread's ID
    private static final ThreadLocal<Integer> threadId =
        ThreadLocal.<Integer>withInitial(()-> {return nextId.getAndIncrement();});

    // Returns the current thread's unique ID, assigning it if necessary
    public static int get() {
        return threadId.get();
    }
}

注意，这里的withInitial方法是使用lambda表达式实现的。 2-另一个用例是当我们想要一个线程安全的实例时，我们不想使用同步，因为同步的性能成本更高。其中一种情况是使用SimpleDateFormat。由于SimpleDateFormat不是线程安全的，所以我们必须提供机制使其线程安全。

public class ThreadLocalDemo1 implements Runnable {
    // threadlocal variable is created
    private static final ThreadLocal<SimpleDateFormat> dateFormat = new ThreadLocal<SimpleDateFormat>(){
        @Override
        protected SimpleDateFormat initialValue(){
            System.out.println("Initializing SimpleDateFormat for - " + Thread.currentThread().getName() );
            return new SimpleDateFormat("dd/MM/yyyy");
        }
    };

    public static void main(String[] args) {
        ThreadLocalDemo1 td = new ThreadLocalDemo1();
        // Two threads are created
        Thread t1 = new Thread(td, "Thread-1");
        Thread t2 = new Thread(td, "Thread-2");
        t1.start();
        t2.start();
    }

    @Override
    public void run() {
        System.out.println("Thread run execution started for " + Thread.currentThread().getName());
        System.out.println("Date formatter pattern is  " + dateFormat.get().toPattern());
        System.out.println("Formatted date is " + dateFormat.get().format(new Date()));
    } 

}

自Java 8发布以来，有更多的声明性方法来初始化ThreadLocal:

ThreadLocal<String> local = ThreadLocal.withInitial(() -> "init value");

在Java 8发布之前，你必须做以下事情:

ThreadLocal<String> local = new ThreadLocal<String>(){
    @Override
    protected String initialValue() {
        return "init value";
    }
};

此外，如果用于ThreadLocal的类的实例化方法(构造函数，工厂方法)不接受任何参数，您可以简单地使用方法引用(在Java 8中引入):

class NotThreadSafe {
    // no parameters
    public NotThreadSafe(){}
}
    
ThreadLocal<NotThreadSafe> container = ThreadLocal.withInitial(NotThreadSafe::new);

注意: 计算是惰性的，因为你传递的java.util.function.Supplier lambda只在调用ThreadLocal#get但value之前没有计算时才会计算。

线程局部变量通常用于防止基于线程的设计中的共享 可变单例或全局变量。

在不使用连接池的情况下，它可以用于为每个线程建立单独的JDBC连接等场景。

private static ThreadLocal<Connection> connectionHolder
           = new ThreadLocal<Connection>() {
      public Connection initialValue() {
           return DriverManager.getConnection(DB_URL);
          }
     };

public static Connection getConnection() {
      return connectionHolder.get();
} 

当您调用getConnection时，它将返回与该线程关联的连接。对于其他属性(如dateformat、事务上下文等)，您不希望在线程之间共享，也可以这样做。

您也可以使用局部变量来实现相同的目的，但是这些资源通常会占用创建时间，因此您不希望在使用它们执行某些业务逻辑时一次又一次地创建它们。然而，ThreadLocal值存储在线程对象本身中，一旦线程被垃圾收集，这些值也就消失了。

这个链接很好地解释了ThreadLocal的用法。

文档说得很好:“每个访问[线程局部变量]的线程(通过它的get或set方法)都有它自己的、独立初始化的变量副本”。

当每个线程必须有自己的某个副本时，可以使用一个。默认情况下，数据在线程之间共享。