Threadlocal是为了，解决多线程环境下变量隔离的问题；

ThreadLocalMap

是threadLocal用来存储数据的内部类，他没有实现任何集合接口，因为它仅供内部使用；
他是在threadLocal定义的，但是它的实例是在thread类中，是为每一个线程创建了一个Map而不是共享的map；
内部定义了一个Entry，key为ThreaLocal，value为存的值，对key使用了虚引用；

static class Entry extends WeakReference<ThreadLocal> {
            /** The value associated with this ThreadLocal. */
            Object value;

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

这里就是今天要探讨的问题，之前一直卡在这个虚引用（虚引用垃圾回收条件是，回收时只要发现是虚引用就会直接回收掉），因为垃圾回收机制的存在我的第一个疑问是：
1、在线程运行时，会不会存在这个变量我放在threadLocal里面了，但是还没使用然后垃圾回收运行，因为是key是虚引用所以被回收掉，直白的说就是这个值我还没用就被回收掉了？
这个问题我查阅虚引用的资料了解到，一个对象是可以同时存在虚引用和强引用的，所以在作用域内ThreadLocal的key存在强引用就不会被回收（ThreadLocalMap的key存放的是ThreadLocal对象，而ThreadLocal使用时会new也就是强引用），见下面代码

public class WeakReferenceDemo {
    static WeakReference<String> weake;

    public static void main(String[] args) {
        test();
        System.out.println("方法外====GC==========前");
        System.out.println("获取的值-" + weake.get());
        System.gc();//已经跳出了test的作用域，所以对象会被回收
        System.out.println("方法外====GC==========后");
        System.out.println("获取的值-" + weake.get());

    }

    public static void test() {
        String str = new String("weak_refrence");
        weake = new WeakReference<String>(str);
        System.out.println("方法里====GC==========前");
        System.out.println("获取的值-" + weake.get());
        System.gc();//这个test方法的作用域里还存在str这个强引用，所以不会被回收；
        System.out.println("方法里====GC==========后");
        System.out.println("获取的值-" + weake.get());
    }
}

输出结果：

方法里====GC==========前
获取的值-weak_refrence
方法里====GC==========后
获取的值-weak_refrence
方法外====GC==========前
获取的值-weak_refrence
方法外====GC==========后
获取的值-null

在threadLocal里面亦是如此，所以不会存在还没使用就被回收的情况，随之而来的是下面的问题；
2、既然回收和作用域有关系，那么我把这个强引用声明为全局的是不是这个变量就一直存在了呢？见下面代码：

public class ThreadLocalDemo01 {
    //把ThreadLocal声明为全局，保证他的生命周期在外部使用时还存活
    static ThreadLocal<Integer> intThread = new ThreadLocal<>();
    static ThreadLocal<String> strThread = new ThreadLocal<>();

    public static void main(String[] args) {
                 //使用线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 100, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(5));
        int threadNum = 10;
                 //使用计数器，使线程同步发生
        CountDownLatch latch = new CountDownLatch(threadNum);
        for (int i = 0; i < threadNum; i++) {
            Thread t = new Thread(new RunableDemo01(latch));
            executor.execute(t);
        }
        try {
            latch.await();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        executor.shutdown();
        System.out.println(intThread.get());//代码1
        System.out.println(strThread.get());//代码2
    }
}

class RunableDemo01 implements Runnable {
    private CountDownLatch latch;
    static Integer num = 1;
    static String str = new String();

    public RunableDemo01(CountDownLatch latch) {
        this.latch = latch;
    }

    @Override
    public void run() {
        method();
        latch.countDown();
        System.gc();
        System.out.println();
    }

    public void method() {

        ThreadLocalDemo01.intThread.set(num);
        int n = ThreadLocalDemo01.intThread.get();
        n++;
        ThreadLocalDemo01.strThread.set(str);
        String s = ThreadLocalDemo01.strThread.get();
        s = Thread.currentThread().getName();
        // System.out.println(n);
        // System.out.println(s);
    }

}

上面的代码把threadLocal声明为全局的，那么这个强引用在代码1、2处应该还是存在的，所以就不会被垃圾回收机制处理掉；执行代码：

null
null

结果为null，没有取到值，被回收呢？
确实是被回收了，但是不是因为虚引用的问题被回收，而是整个map被回收了，原因分析：
这个问题之所以会出现，其实是没有好好理解ThreadLocal的源码问题，之前介绍了ThreadLocalMap它是定义在ThreadLocal里面的但是是在Thread里面实例的，所以他的生命周期是和线程相同的，因为在代码1、2处已经到了主线程了，而我们放值的时候是在子线程，1、2处子线程已经结束，那么他们的ThreadLocalMap也已经失效被回收了，主线程ThreadLocalMap有没有放入这值所以返回null；
以上就是目前对于Thread的探讨，发现新问题将继续加推。