ThreadLocal详解及仿写实例

1. 进程和线程

ThreadLocal是一个工具类，ThreadLocal是怎么那么产生的？

ThreadLoal是为了解决线程问题产生的，那么我们需要先了解下进程和线程。

所谓进程，是包括程序，资源的一次物理活动，进程需要内存中的程序，程序需要进行资源调度，包括IO，网络调用等。进程是早期计算机设计时候运行的一个基本单位。

对于线程来说，它比进程更加细粒化，线程是最小的运行单元我们可以把它当作一个迷你的进程，但是线程会更加灵活，线程涉及到资源共享。

当一套程序完成后，就可以进行处理，加载到内存中。相对于计算机，这套代码是“面向过程“的，因为它只是规范了一套流程。当计算机开始使用这套流程时，便会以最小的单位--线程来使用。正常情况下，每个线程都会运行同样的一段代码。这套流程会有自己的资源，资源对于这套流程是绝对安全的，因为这套流程是单线程。如果多个线程同时访问同一处资源，那么就会出现线程间的资源分配问题。资源访问何时给线程A，又何时给线程B，这些便是多线程环境下最棘手的点。多线程带来的挑战，无非就是正确处理资源的分配。

2.ThreadLocal是什么？

ThreadLocal可以用来解决线程中变量的保存和传递。由于Thread类维护了一个threadLocaMap的变量，所以在线程的生命周期开始之后，中间状态可以保存在线程的threadLocaMap中，由于每次获取threadLocaMap需要先获取线程实例，所以自然就做到了线程安全。

ThreadLocalmap维护了一个Entry数组，数据的定义如下

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

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

    private static final int INITIAL_CAPACITY = 16;

    private Entry[] table;

    private int size = 0;

    private int threshold; // Default to 0
}

 这里截取了部分的定义，ThreadLocaMap中维护了一个Entry数组，该Entry继承了WeakRefernce<?>，其中key值为当前threadLocal，value值为传入的threadLcoa.set传入的参数。可以看出，定义了几个threadLocal对象，entry数组中就会有几个实际使用的节点。ThreadLocal类的实现给我的感觉就是一个线程工具类，主要的工作都由ThreadLocalMap类来维护，ThreadLocal承担了获取线程，拿到ThreadLocalMap实例的职责。所以自己写了个简单的demo。

3. ThreadLocal仿写

/**
 * @Author caizhenya
 * @Date 2020/7/19
 * @Descrition
 **/
public class MapUtil<T> {

    private int gap = 1;

    public void set(Object val) {
        Thread thread = Thread.currentThread();
        MyThread myThread = null;
        if (thread instanceof MyThread) {
            myThread = (MyThread) thread;
        }

        assert myThread != null;

        LocalVarMap localVarMap = myThread.getMap();
        if (localVarMap == null) {
            create(myThread, val);
        } else {
            localVarMap.set(this, val);
        }
    }

    public LocalVarMap getMap(MyThread myThread) {
        return myThread.map;
    }

    public T get() {
        Thread thread = Thread.currentThread();
        MyThread myThread = null;
        if (thread instanceof MyThread) {
            myThread = (MyThread) thread;
        }

        assert myThread != null;
        LocalVarMap localVarMap = myThread.getMap();

        if (localVarMap == null) {
            return null;
        }

        return (T) localVarMap.get(this);
    }

    public void create(MyThread myThread, Object val) {
        ;
        if (myThread.map == null) {
            myThread.map = new LocalVarMap();
            myThread.map.create();
            myThread.map.entries[0] = new LocalVarMap.Entry(this, val);
        }
    }

    static class LocalVarMap {

        private int initalSize = 16;

        private Entry[] entries;

        public void create() {
            entries = new Entry[initalSize];
        }

        public void set(MapUtil<?> mapUtil, Object val) {
            int size = initalSize;
            for (int i = 0; i < size; i++) {
                if (entries[i] == null) {
                    entries[i] = new Entry(mapUtil, val);
                    break;
                }

            }
        }

        public Object get(MapUtil<?> mapUtil) {

            int size = initalSize;
            for (int i = 0; i < size; i++) {
                if (entries[i].get() != null && entries[i].get() == mapUtil) {
                    return entries[i].value;
                }
            }
            return null;
        }

        static class Entry extends WeakReference<MapUtil<?>> {
            private Object value;

            public Entry(MapUtil<?> referent, Object value) {
                super(referent);
                this.value = value;
            }
        }

    }
}　

public class MyThread extends Thread {

    MapUtil.LocalVarMap map;

    public MyThread(Task task) {
        super(task);
    }

    public MapUtil.LocalVarMap getMap() {
        return this.map;
    }

}

public class Task implements Runnable {


    private MapUtil<String> mapUtil = new MapUtil<>();
    private MapUtil<Object> objectMapUtil = new MapUtil<>();

    private ThreadLocal<String> threadLocal = new ThreadLocal<>();

    @Override
    public void run() {

        mapUtil.set("mapUtil");
        objectMapUtil.set(1L);
        threadLocal.set("threadLocal");

        System.out.println(Thread.currentThread().getName() + ",,," + mapUtil.get());
        System.out.println(Thread.currentThread().getName() + ",,," + objectMapUtil.get());
        System.out.println(Thread.currentThread().getName() + ",,," + threadLocal.get());

        System.gc();

        System.out.println(Thread.currentThread().getName() + ",,," + mapUtil.get());
        System.out.println(Thread.currentThread().getName() + ",,," + objectMapUtil.get());
        System.out.println(Thread.currentThread().getName() + ",,," + threadLocal.get());
    }
} 

public class Main {

    public static void main(String[] args) {
        MyThread myThread = new MyThread(new Task());
        myThread.start();
    }
}

 Entry继承了WeakReference，导致在每一次GC中，只要存在弱引用，都会回收弱引用的指向，这样会导致如果弱引用回收前维护的实例对象没有回收的情况下，发生内存泄漏，尤其是在线程复用的情况下发生频繁。所以在使用线程池等此类可以复用线程的场景下，需要手动调用threadLocal的remove方法，让Entry的value值可以被及时回收。

• 使用场景

ThreadLocal类的使用场景主要是线程变量维护以及传递的情况下用的多。比如生成，保存，获取用户的个人信息，传递对象状态等。