大家好，这里是教授.F

引入：

        1. ThreadLocal 的作用，可以实现在同一个线程数据共享, 从而解决多线程数据安全问题.

         2. ThreadLocal 可以给当前线程关联一个数据(普通变量、对象、数组)set 方法[源码!]

        3. ThreadLocal 可以像 Map 一样存取数据，key 为当前线程, get 方法

        4. 每一个 ThreadLocal 对象，只能为当前线程关联一个数据，如果要为当前线程关联多个数据，就需要使用多个 ThreadLocal 对象实例

         5. 每个 ThreadLocal 对象实例定义的时候，一般为 static 类型6. ThreadLocal 中保存数据，在线程销毁后，会自动释放

源码解读：

        

package com.hspedu.threadlocal;

public class T2Dao {
    public void update(){
        //取出线程关联的threadLocal1对象的数据
        /**
         * public T get() {
         *           //1.得到当前线程对象
         *         return get(Thread.currentThread());
         *     }
         * private T get(Thread t) {
         *          //2.通过线程获取到对应的ThreadLocalMap
         *         ThreadLocalMap map = getMap(t);
         *          //3.如果map不为空，根据当前的threadLocal对象，得到对应的Entry
         *         if (map != null) {
         *             ThreadLocalMap.Entry e = map.getEntry(this);
         *              //4.如果e不为空，
         *             if (e != null) {
         *                 @SuppressWarnings("unchecked")
         *                 T result = (T) e.value;//关联的数据
         *                 return result;
         *             }
         *         }
         *         return setInitialValue(t);
         *     }
         */
        Object object = T1.threadLocal.get();

        String name = Thread.currentThread().getName();
        System.out.println("在dao的update线程是" + name);
     }
}
package com.hspedu.threadlocal;

import java.util.TreeMap;

public class T1 {
    //创建ThreadLocal对象，做成public static
    public static ThreadLocal<Object> threadLocal = new InheritableThreadLocal<>();
    public static ThreadLocal<Object> threadLocal2 = new InheritableThreadLocal<>();
    public static class Task implements Runnable{
        @Override
        public void run() {
            System.out.println("aaa");
            Dog dog = new Dog();
            Rig pig = new Rig();
            //给threadLocal对象放入set dog，
            System.out.println("task放入了dog" + Thread.currentThread().getName());
            /**
             * 源码解读：
             *  public void set(T value) {
             *         set(Thread.currentThread(), value);//1.获取当前线程，将t传给下面
             *         if (TRACE_VTHREAD_LOCALS) {
             *             dumpStackIfVirtualThread();
             *         }
             *     }
             *  private void set(Thread t, T value) {
             *         ThreadLocalMap map = getMap(t);//底层还是关联到当前线程
             *         //2.通过线程对象，获取到ThreadLocalMap
             *         // ThreadLocalMap类型是ThreadLoval.ThreadLocalMpa的静态内部类
             *         //3.如果map不为空，就将数据（dog，pid。。。）放入map -key:threadLocal  value：存放的数据
             *         //   threadlocal只能关联一个数据，如果再set，就会替换
             *         //   如果map为null，就创建一个和当前线程关联的ThreadLocalMap，并且将该数据放入
             *         if (map != null) {
             *             map.set(this, value);//如果有多个threadLocal会进行替换
             *         } else {
             *             createMap(t, value);
             *         }
             *     }
             */
            threadLocal.set(dog);
            //threadLocal.set(pig);会替换
            threadLocal2.set(pig);
            System.out.println("task在run方法中线程=" + Thread.currentThread().getName());
            //通过t1调用service
            new T1Service().update();
        }
        public static void main(String[] args) {
            new Thread(new Task()).start();//启动一个新线程，但不是主线程
            System.out.println("aa");
        }
    }
}