ThreadLocal资源隔离和存在的问题

学习ThreadLocal，必须知道的几个数据类型：

1.Thread
2.ThreadLocalMap
3.Entry
4.ThreadLocal
5.WeakReference

使用ThreadLocal进行资源隔离的注意事项：

initValue初始化的时候需要return new Object(); 让每个对象持有不同的对象引用

ThreadLocal存在的问题：

1.在使用线程池时，由于线程池中的核心线程再使用完成后并不会被销毁。这个时候如果前一个任务在ThreadLocal中set一个值， 那么后续任务可以访问前一个任务在ThreadLocal中set的值，这样就有可能到导致业务处理的时候会出现错误
2.假如ThreadLocal并没有声明为static，由于ThreadLocalMap中它是 由Entry数组构成的，Entry
将ThreadLocal通过弱引用指向，就有可能出现发生GC时，Entry.get = null但是Value还有值的情况。这种情况也是内存泄露的一种
3.ThreadLocal没办法解决共享变量的更新问题，存在并发安全问题(下面会有代码给出)

ThreadLocal的使用建议

1.不管是使用到线程池还是没有使用到线程池。在每个任务在执行完业务处理后，需要手动的调用ThreadLocal.remove方法，清空之前set的数据
2.ThreadLocal声明为static，避免出现内存泄露的问题
3.ThreadLocal只做资源隔离和参数传递，没办法保证并发情况下的资源安全问题

资源隔离例子

package EveryTest.EveryThreadLocal;

/**
 * ThreadLocal资源隔离
 *
 * @author wuhui
 * @date 2020/05/08
 */
public class ThreadLocalTest {

    private static ThreadLocal<StringBuilder> threadLocal = new ThreadLocal<StringBuilder>() {

        @Override
        protected StringBuilder initialValue() {
            // 资源隔离，每个线程拥有自己的StringBuilder
            return new StringBuilder("init");
        }
    };

    public static void main(String[] args) {

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                StringBuilder sb = threadLocal.get();
                for (int num = 0; num < 10; num++) {
                    sb.append("-").append(num);
                }
                System.out.println(Thread.currentThread().getName() + sb.toString());
            }, "MyThread_" + i).start();
        }
    }

    /* 输出结果
    *   MyThread_0init-0-1-2-3-4-5-6-7-8-9
        MyThread_3init-0-1-2-3-4-5-6-7-8-9
        MyThread_2init-0-1-2-3-4-5-6-7-8-9
        MyThread_4init-0-1-2-3-4-5-6-7-8-9
        MyThread_1init-0-1-2-3-4-5-6-7-8-9
        MyThread_5init-0-1-2-3-4-5-6-7-8-9
        MyThread_6init-0-1-2-3-4-5-6-7-8-9
        MyThread_7init-0-1-2-3-4-5-6-7-8-9
        MyThread_8init-0-1-2-3-4-5-6-7-8-9
        MyThread_9init-0-1-2-3-4-5-6-7-8-9
    * */
}

ThreadLocal操作共享变量出现并发安全的问题的例子

package EveryTest.EveryThreadLocal;

import java.util.concurrent.CountDownLatch;

/**
 * ThreadLocal没办法解决共享变量的更新问题，存在并发安全问题
 *
 * @author wuhui
 * @date 2020/05/08
 */
public class ThreadLocalTest2 {

    private static NumObject numObject = new NumObject(0);

    private static ThreadLocal<NumObject> threadLocal = new ThreadLocal<NumObject>() {

        @Override
        protected NumObject initialValue() {
            return numObject;
        }
    };

    public static void main(String[] args) {

        CountDownLatch countDownLatch = new CountDownLatch(MyConst.THREAD_NUM);

        for (int i = 1; i <= MyConst.THREAD_NUM; i++) {
            new Thread(() -> {
                NumObject numObject = threadLocal.get();
                for (int num = 0; num < MyConst.EVERY_THREAD_INCR_TIMES; num++) {
                    numObject.incrementValue();
                }
                // 每个线程打印的结果需要是10的整数倍才正确
                System.out.println(Thread.currentThread().getName() + ":" + numObject.getValue());
                countDownLatch.countDown();
            }, MyConst.THREAD_NAME_PREFIX + i).start();
        }

        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 最后结果应该要是THREAD_NUM * EVERY_THREAD_INCR_TIMES才对，如果不是 说明ThreadLocal并不能解决并发更新共享变量的问题
        System.out.println(numObject.getValue());
    }
}

class NumObject {

    private int value;

    public NumObject() {

    }

    public NumObject(int value) {
        this.value = value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public void incrementValue() {
        this.value++;
    }

    public void decrementValue() {
        this.value--;
    }

    @Override
    public String toString() {
        return "NumObject{" +
                "value=" + value +
                '}';
    }
}

class MyConst {

    public static final String THREAD_NAME_PREFIX = "MYTHREAD_";
    /**
     * 可通过调节线程个数验证结果，放大线程数量增加出现并发更新共享变量问题出现的概率
     */
    public static final int THREAD_NUM = 100;

    public static final int EVERY_THREAD_INCR_TIMES = 1000;

    private MyConst() {

    }
}

测试了几次 数据分别为：
98750
97558
98344
96238
96904
98921
从测试结果来看，都不是100*1000。由此得出结论，ThreadLocal确实存在并发更新的安全问题