簡單理解ThreadLocal

ThreadLocal類的介紹

ThreadLocal，從表面上讀英文的意思爲線程本地變量，這樣也許更好理解了，就是每一個線程本身獨有的，不與其它線程共享的變量。

經常使用的就這幾個，倆內部類，四個方法。

• get()方法是用來獲取ThreadLocal在當前線程中保存的變量副本。
• set()用來設置當前線程中變量的副本。
• remove()用來移除當前線程中變量的副本。
• initialValue()是一個protected方法，通常是用來在使用時進行重寫的，它是一個延遲加載方法。ThreadLocal沒有被當前線程賦值時或當前線程剛調用remove方法後調用get方法，返回此方法值。

舉例：

定義兩個不一樣任務的線程，分別向各自的本地變量中存放值，見證兩個線程本地變量中的內容是互不干擾的。

public class MyThreadLocal {
    // 採用匿名內部類的方式來重寫initialValue方法
    private static final ThreadLocal<Object> threadLocal = new ThreadLocal<Object>() {
        /**
         * ThreadLocal沒有被當前線程賦值時或當前線程剛調用remove方法後調用get方法，返回此方法值
         */
        @Override
        protected Object initialValue() {
            System.out.println("調用get方法時，當前線程共享變量沒有設置，調用initialValue獲取默認值！");
            return null;
        }
    };

    // 操縱int類型的任務線程
    public static class MyIntegerTask implements Runnable {
        private String name;

        MyIntegerTask(String name) {
            this.name = name;
        }

        public void run() {
            for (int i = 0; i < 5; i++) {
                // ThreadLocal.get方法獲取線程變量
                if (null == MyThreadLocal.threadLocal.get()) {
                    // ThreadLocal.et方法設置線程變量
                    MyThreadLocal.threadLocal.set(0);
                    System.out.println("線程" + name + ": 0");
                } else {
                    int num = (Integer) MyThreadLocal.threadLocal.get();
                    MyThreadLocal.threadLocal.set(num + 1);
                    System.out.println("線程" + name + ": " + MyThreadLocal.threadLocal.get());
                    if (i == 3) {
                        MyThreadLocal.threadLocal.remove();
                    }
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 操縱string類型的任務線程
    public static class MyStringTask implements Runnable {
        private String name;
        MyStringTask(String name) {
            this.name = name;
        }
        public void run() {
            for (int i = 0; i < 5; i++) {
                if (null == MyThreadLocal.threadLocal.get()) {
                    MyThreadLocal.threadLocal.set("a");
                    System.out.println("線程" + name + ": a");
                } else {
                    String str = (String) MyThreadLocal.threadLocal.get();
                    MyThreadLocal.threadLocal.set(str + "a");
                    System.out.println("線程" + name + ": " + MyThreadLocal.threadLocal.get());
                }
                try {
                    Thread.sleep(800);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        new Thread(new MyIntegerTask("IntegerTask1")).start();
        new Thread(new MyStringTask("StringTask1")).start();
    }

}

運行結果：

調用get方法時，當前線程共享變量沒有設置，調用initialValue獲取默認值！
線程IntegerTask1: 0
調用get方法時，當前線程共享變量沒有設置，調用initialValue獲取默認值！
線程StringTask1: a
線程StringTask1: aa
線程IntegerTask1: 1
線程StringTask1: aaa
線程IntegerTask1: 2
線程StringTask1: aaaa
線程IntegerTask1: 3
線程StringTask1: aaaaa
調用get方法時，當前線程共享變量沒有設置，調用initialValue獲取默認值！
線程IntegerTask1: 0

get方法分析

涉及到的源碼：

get();方法：供ThreadLocal對象來調用

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

getMap();方法：這個方法是返回當前線程t中的一個成員變量threadLocals，它是Thread類中的一個內部類

ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
}

看一下ThreadLocalMap的實現：能夠看到ThreadLocalMap的Entry繼承了WeakReference(弱引用類)，而且使用ThreadLocal做爲鍵值。

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;
            }
        }
    
    。。。。。。。。。

    }

getEntry();方法

private Entry getEntry(ThreadLocal<?> key) {
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, e);
}

setInitialValue();方法：就是若是map不爲空，就設置鍵值對，爲空，再建立Map

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;
    }

createMap();方法：若是map爲空，就初始化ThreadLocalMap

void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
}

不難看出，get()方法，首先獲取當前的線程，而後經過getMap(t)方法獲取到一個map，map的類型爲ThreadLocalMap。而後接着下面獲取到<key,value>鍵值對，若是獲取成功，則返回value值，若是map爲空，則調用setInitialValue方法返回value。

測試完上面的例子，看完get方法的實現，應該明白ThreadLocal是怎麼個原理了，大體以下(就是這樣的)：首先，在每一個線程Thread內部有一個ThreadLocal.ThreadLocalMap類型的成員變量threadLocals，這個threadLocals就是用來存儲實際的變量的，鍵值爲當前ThreadLocal變量，value爲變量(好比說上面定義的String變量或者Integer變量)。初始時，在Thread裏面，threadLocals爲空，當經過ThreadLocal變量調用get()方法或者set()方法，就會對Thread類中的threadLocals進行初始化，而且以當前ThreadLocal變量爲鍵值，以ThreadLocal要保存的變量爲value，存到threadLocals。若是要使用副本變量，就能夠經過get方法在threadLocals裏面查找。

這種存儲結構的好處：

1. 線程死去的時候，線程共享變量ThreadLocalMap則銷燬。
2. ThreadLocalMap<ThreadLocal,Object>鍵值對數量爲ThreadLocal的數量，通常來講ThreadLocal數量不多，相比在ThreadLocal中用Map<Thread, Object>鍵值對存儲線程共享變量（Thread數量通常來講比ThreadLocal數量多），性能提升不少。

ThreadLocal的應用場景

最多見的ThreadLocal使用場景爲 用來解決 數據庫鏈接、Session管理等。

好比如下，代碼來自：https://www.iteye.com/topic/1...

private static final ThreadLocal threadSession = new ThreadLocal();

    public static Session getSession() throws InfrastructureException {
        Session s = (Session) threadSession.get();
        try {
            if (s == null) {
                s = getSessionFactory().openSession();
                threadSession.set(s);
            }
        } catch (HibernateException ex) {
            throw new InfrastructureException(ex);
        }
        return s;
}

關於ThreadLocal致使的內存泄漏問題，和解決辦法

1. 每一個thread中都存在一個map，map的類型是ThreadLocal.ThreadLocalMap。 Map中的key爲一個threadlocal實例。 這個Map的確使用了弱引用，不過弱引用只是針對key。每一個key都弱引用指向threadlocal，當把threadlocal實例的引用置爲null之後,沒有任何強引用指向threadlocal實例，因此threadlocal將會被gc回收。 可是value卻不能回收，由於存在一條從currentThread鏈接過來的強引用。只有當前thread結束之後，currentThread纔不會存在棧中，強引用斷開，CurrentThread，Map，value將所有被GC回收。
2. 因此得出一個結論就是隻要這個線程對象被gc回收，就不會出現內存泄露，但在threadLocal設爲null和線程結束這段時間不會被回收的，就發生了咱們認爲的內存泄露。其實這是一個對概念理解的不一致，也沒什麼好爭論的。最要命的是線程對象不被回收的狀況，這就發生了真正意義上的內存泄露。好比使用線程池的時候，線程結束是不會銷燬的，會再次使用的。就可能出現內存泄露。
3. Java爲了最小化減小內存泄露的可能性和影響，在ThreadLocal的get,set的時候都會清除線程Map裏全部key爲null的value。因此最怕的狀況就是，threadLocal對象設null了，開始發生「內存泄露」，而後使用線程池，這個線程結束，線程放回線程池中不銷燬，這個線程一直不被使用，或者分配使用了又再也不調用get,set方法，那麼這個期間就會發生真正的內存泄露。

通常有兩種方法：

1. 使用完線程共享變量後，顯示調用ThreadLocalMap.remove方法清除線程共享變量
2. JDK建議ThreadLocal定義爲private static，static爲了防止多實例，消除弱引用，但也有很差的地方就是延長了它的生命週期，致使ThreadLocalMap中的value一直不釋放，因此若是加上static，必定要手動remove。