1、ThreadLocal是什么

ThreadLocal叫做线程变量，意思是ThreadlLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的，也就是说，改变量是当前线程独有的变量。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。
ThreadLocal中填充的变量是属于当前线程的，每个线程都可以通过set()和get()来对这个变量进行操作，这个变量对其他线程而言是隔离的，也就实现了线程的数据隔离。

ThreadLocal变量，线程局部变量，同一个ThreadLocal所包含的对象，在不同的线程中有不同的副本，这里有几点需要注意：

  • 每个线程内有自己的实例副本，且该副本只能由当前线程使用。
  • 既然每个线程有自己的实例副本，其他线程不可访问，那就不存在多线程间共享的问题。

ThreadLocal变量通常被private static修饰，当一个线程结束时，它所使用的所有ThreadLocal的实例副本都可被回收。

2、使用场景和如何使用

ThreadLocal适用于每个线程需要自己独立的实例，且该实例需要在多个方法中被使用，也即变量在线程间隔离而在方法或类间共享的场景。
简单使用：

  1. package com.atguigu.sh.juc2;
  3. /**
  4.  * 本类说明：
  5.  * ThreadDemo
  6.  * @author yuanhai
  7.  */
  8. public class ThreadLocalDemo {
  10.     private static ThreadLocal<String> localVar = new ThreadLocal<String>();
  12.     static void print(String str) {
  13.         //打印当前线程中本地内存中本地变量的值
  14.         System.out.println(str + " :" + localVar.get());
  15.         //清除本地内存中的本地变量
  16.         localVar.remove();
  18.     }
  20.     public static void main(String[] args) throws InterruptedException {
  21.         new Thread(new Runnable() {
  22.             public void run() {
  23.                 ThreadLocalDemo.localVar.set("local_A");
  24.                 print("A");
  25.                 //打印本地变量
  26.                 System.out.println("after remove : " + localVar.get());
  28.             }
  29.         },"A").start();
  31.         Thread.sleep(1000);
  33.         new Thread(new Runnable() {
  34.             public void run() {
  35.                 ThreadLocalDemo.localVar.set("local_B");
  36.                 print("B");
  37.                 System.out.println("after remove : " + localVar.get());
  39.             }
  40.         },"B").start();
  42.     }
  46. }

3、ThreadLocal和synchronized的区别

ThreadLocal是与线程绑定一个变量，ThreadLocal和synchronized都用于解决多线程的并发访问，但是有本质上的区别：

  • synchronized用于线程间的数据共享，但是ThreadLocal用于线程间的数据隔离。
  • synchronized是利用锁机制，使变量或者代码块在某一时刻只能被一个线程访。，但ThreadLocal为每个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。而synchronized正好相反，它用于多个线程间通信时能够获得数据共享。

4、 ThreadLocal的原理

简单概述起来，就是向ThreadLocal里面存东西，就是向它里面的Map存东西，然后ThreadLocal把这个Map挂到当前线程下，这样Map就只属于这个线程了。
或者可以总结为：ThreadLocal中有一个静态内部类ThreadLocalMap，它实现了键值对的设置和获取。其中键为当前ThreadLocal对象，值为我们设置的对象。每个线程中都有一个独立的ThreadLocalMap副本，它所存储的值，只能被当前线程读取和修改。ThreadLocal类通过操作每一个线程特有的ThreadLocalMap副本，从而实现了变量访问在不同线程中的隔离。因为每个线程的变量都是自己特有的，完全不会有并发错误。

来分析一下。

先看下ThreadLocal的中的ThreadLocalMap。
ThreadLocalMap是ThreadLocal的静态内部类，它的构成，主要是用Entry来保存数据，而且还继承了弱引用。在Entry内部用ThreadLocal作为key，使用我们设置的vaue作为value。

  static class ThreadLocalMap {

        /**
         * The entries in this hash map extend WeakReference, using
         * its main ref field as the key (which is always a
         * ThreadLocal object).  Note that null keys (i.e. entry.get()
         * == null) mean that the key is no longer referenced, so the
         * entry can be expunged from table.  Such entries are referred to
         * as "stale entries" in the code that follows.
         */
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }


    }

再来看下ThreadLocal的set()方法：

 public void set(T value) {
        //1、获取当前线程
        Thread t = Thread.currentThread();
        //2、获取线程中的属性 threadLocalMap ,如果threadLocalMap 不为空，
        //则直接更新要保存的变量值，否则创建threadLocalMap，并赋值
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            // 初始化thradLocalMap 并赋值
            createMap(t, value);
    }

ThreadLocal在set()赋值的时候，先获取当前线程thread，并且获取线程中的ThreadLocalMap属性。如果map属性不为空，那么直接更新value的值，如果map为空，则实例化ThreadLocalMap，并为value赋值。
ThreadLocal的get()方法：

    public T get() {
        //1、获取当前线程
        Thread t = Thread.currentThread();
        //2、获取当前线程的ThreadLocalMap
        ThreadLocalMap map = getMap(t);
        //3、如果map数据为空，
        if (map != null) {
            //3.1、获取threalLocalMap中存储的值
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        //如果是数据为null，则初始化，初始化的结果，TheralLocalMap中存放key值为threadLocal，值为null
        return setInitialValue();
    }


private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }

ThreadLocal的remove()方法：

 public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

remove()方法会直接将ThreadLocal对应的值从当前线程中的ThreadLocalMap中删除。
为什么要删除，这涉及到内存泄漏问题:
内存泄露问题：ThreadLocalMap中使用的key为ThreadLocal的弱引用。弱引用的特点是：如果这个对象只存在弱引用，那么下一次垃圾回收时必然会被清理掉。所以如果ThreadLocal没有被外部强引用的情况下在垃圾回收的时候会被清理掉。这样一来，ThreadLocalMap中使用的key是当前这个ThreadLocal，也会被清理掉。但是value是强引用，不会被清理掉，这样一来就会出现key为null的value。这样就会有一个问题，如果没有将ThreadLocal内的变量删除或者替换掉，它的生命周期将会和线程共存，但是线程池对县城管理都是采用线程复用的方法，在线程池中线程很难结束甚至永远不会结束，这意味着，这些key为null的value永远不会被回收，从而导致内存泄漏。
怎么解决内存泄漏：remove()方法会对key为null的Entry进行清除（主要是调用了expungeStaleEntry()方法，将Entry的value清空，这样等下一次垃圾回收时，这些Entry将会被彻底回收。） get()、set()方法也能对key为null的Entry进行清除。