簡單理解ThreadLocal

ThreadLocal類的介紹

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

常用的就這幾個，倆內(nèi)部類，四個方法。

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

舉例：

定義兩個不同任務(wù)的線程，分別向各自的本地變量中存放值，見證兩個線程本地變量中的內(nèi)容是互不干擾的。

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

    // 操縱int類型的任務(wù)線程
    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方法設(shè)置線程變量
                    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類型的任務(wù)線程
    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();
    }

}

運行結(jié)果：

調(diào)用get方法時，當(dāng)前線程共享變量沒有設(shè)置，調(diào)用initialValue獲取默認(rèn)值！
線程IntegerTask1: 0
調(diào)用get方法時，當(dāng)前線程共享變量沒有設(shè)置，調(diào)用initialValue獲取默認(rèn)值！
線程StringTask1: a
線程StringTask1: aa
線程IntegerTask1: 1
線程StringTask1: aaa
線程IntegerTask1: 2
線程StringTask1: aaaa
線程IntegerTask1: 3
線程StringTask1: aaaaa
調(diào)用get方法時，當(dāng)前線程共享變量沒有設(shè)置，調(diào)用initialValue獲取默認(rèn)值！
線程IntegerTask1: 0

get方法分析

涉及到的源碼：

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

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();方法：這個方法是返回當(dāng)前線程t中的一個成員變量threadLocals，它是Thread類中的一個內(nèi)部類

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

看一下ThreadLocalMap的實現(xiàn)：可以看到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不為空，就設(shè)置鍵值對，為空，再創(chuàng)建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()方法，首先獲取當(dāng)前的線程，然后通過getMap(t)方法獲取到一個map，map的類型為ThreadLocalMap。然后接著下面獲取到<key,value>鍵值對，如果獲取成功，則返回value值，如果map為空，則調(diào)用setInitialValue方法返回value。

測試完上面的例子，看完get方法的實現(xiàn)，應(yīng)該明白ThreadLocal是怎么個原理了，大致如下(就是這樣的)：首先，在每個線程Thread內(nèi)部有一個ThreadLocal.ThreadLocalMap類型的成員變量threadLocals，這個threadLocals就是用來存儲實際的變量的，鍵值為當(dāng)前ThreadLocal變量，value為變量(比如說上面定義的String變量或者Integer變量)。初始時，在Thread里面，threadLocals為空，當(dāng)通過ThreadLocal變量調(diào)用get()方法或者set()方法，就會對Thread類中的threadLocals進行初始化，并且以當(dāng)前ThreadLocal變量為鍵值，以ThreadLocal要保存的變量為value，存到threadLocals。如果要使用副本變量，就可以通過get方法在threadLocals里面查找。

這種存儲結(jié)構(gòu)的好處：

  1. 線程死去的時候，線程共享變量ThreadLocalMap則銷毀。
  2. ThreadLocalMap<ThreadLocal,Object>鍵值對數(shù)量為ThreadLocal的數(shù)量，一般來說ThreadLocal數(shù)量很少，相比在ThreadLocal中用Map<Thread, Object>鍵值對存儲線程共享變量（Thread數(shù)量一般來說比ThreadLocal數(shù)量多），性能提高很多。

ThreadLocal的應(yīng)用場景

最常見的ThreadLocal使用場景為 用來解決 數(shù)據(jù)庫連接、Session管理等。

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

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

關(guān)于ThreadLocal導(dǎo)致的內(nèi)存泄漏問題，和解決辦法

image

  1. 每個thread中都存在一個map，map的類型是ThreadLocal.ThreadLocalMap。 Map中的key為一個threadlocal實例。 這個Map的確使用了弱引用，不過弱引用只是針對key。每個key都弱引用指向threadlocal，當(dāng)把threadlocal實例置為null以后,沒有任何強引用指向threadlocal實例，所以threadlocal將會被gc回收。 但是value卻不能回收，因為存在一條從currentThread連接過來的強引用。只有當(dāng)前thread結(jié)束以后，currentThread才不會存在棧中，強引用斷開，CurrentThread，Map，value將全部被GC回收。

  2. 所以得出一個結(jié)論就是只要這個線程對象被gc回收，就不會出現(xiàn)內(nèi)存泄露，但在threadLocal設(shè)為null和線程結(jié)束這段時間不會被回收的，就發(fā)生了我們認(rèn)為的內(nèi)存泄露。其實這是一個對概念理解的不一致，也沒什么好爭論的。最要命的是線程對象不被回收的情況，這就發(fā)生了真正意義上的內(nèi)存泄露。比如使用線程池的時候，線程結(jié)束是不會銷毀的，會再次使用的。就可能出現(xiàn)內(nèi)存泄露。

  3. Java為了最小化減少內(nèi)存泄露的可能性和影響，在ThreadLocal的get,set的時候都會清除線程Map里所有key為null的value。所以最怕的情況就是，threadLocal對象設(shè)null了，開始發(fā)生“內(nèi)存泄露”，然后使用線程池，這個線程結(jié)束，線程放回線程池中不銷毀，這個線程一直不被使用，或者分配使用了又不再調(diào)用get,set方法，那么這個期間就會發(fā)生真正的內(nèi)存泄露。

一般有兩種方法：

  1. 使用完線程共享變量后，顯示調(diào)用ThreadLocalMap.remove方法清除線程共享變量
  2. JDK建議ThreadLocal定義為private static，這樣ThreadLocal的弱引用問題則不存在了。
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

友情鏈接更多精彩內(nèi)容