|
在閱讀《Java Concurrency In Practice》時，書中提到ThreadLocal是一種更為規(guī)范常用的Thread Confine方式。于是想仔細分析一下ThreadLocal的實現方式。曾經轉載了一篇關于ThreadLocal的文章：hi.baidu.com/gefforey520/blog/item/c3bb64fa4ad1779358ee902c.html，其中提到ThreadLocal的實現方式是聲明一個Hashtable,然后以Thread.currentThread()為key，變量的拷貝為value。今天閱讀源碼才知道實現方式已經大為改變，下面來看代碼。
/** * ThreadLocals rely on per-thread linear-probe hash maps attached to each * thread (Thread.threadLocals and inheritableThreadLocals). The ThreadLocal * objects act as keys, searched via threadLocalHashCode. This is a custom * hash code (useful only within ThreadLocalMaps) that eliminates collisions * in the common case where consecutively constructed ThreadLocals are used * by the same threads, while remaining well-behaved in less common cases. */ private final int threadLocalHashCode = nextHashCode(); /** * The next hash code to be given out. Updated atomically. Starts at zero. */ private static AtomicInteger nextHashCode = new AtomicInteger(); /** * The difference between successively generated hash codes - turns implicit * sequential thread-local IDs into near-optimally spread multiplicative * hash values for power-of-two-sized tables. */ private static final int HASH_INCREMENT = 0x61c88647; /** * Returns the next hash code. */ private static int nextHashCode() { return nextHashCode.getAndAdd(HASH_INCREMENT); } /** * Creates a thread local variable. */ public ThreadLocal() { } ThreadLocal只有三個變量，從構造函數知道，在創(chuàng)建一個ThreadLocal實例時，只是調用nextHashCode方法將nextHashCode的值賦給實例的threadLocalHashCode，然后nextHashCode的值增加HASH_INCREMENT這個值。 因此ThreadLocal實例的變量只有threadLocalHashCode，而且是final的，用來區(qū)分不同的ThreadLocal實例。 再來看其get方法： /** * Returns the value in the current thread's copy of this thread-local * variable. If the variable has no value for the current thread, it is * first initialized to the value returned by an invocation of the * {@link #initialValue} method. * * @return the current thread's value of this thread-local */ public T get() { Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) { ThreadLocalMap.Entry e = map.getEntry(this); if (e != null) return (T) e.value; } return setInitialValue(); } 其中調用getMap(Thread t)返回ThreadLocalMap，ThreadLocalMap是內部靜態(tài)類，部分代碼如下： /** * ThreadLocalMap is a customized hash map suitable only for maintaining * thread local values. No operations are exported outside of the * ThreadLocal class. The class is package private to allow declaration of * fields in class Thread. To help deal with very large and long-lived * usages, the hash table entries use WeakReferences for keys. However, * since reference queues are not used, stale entries are guaranteed to be * removed only when the table starts running out of space. */ static class ThreadLocalMap { /** * The entries in this hash map extend WeakReference, using its main ref * field as the key (which is always a ThreadLocal object). Note that * null keys (i.e. entry.get() == null) mean that the key is no longer * referenced, so the entry can be expunged from table. Such entries are * referred to as "stale entries" in the code that follows. */ static class Entry extends WeakReference<ThreadLocal> { /** The value associated with this ThreadLocal. */ Object value; Entry(ThreadLocal k, Object v) { super(k); value = v; } } /** * The initial capacity -- MUST be a power of two. */ private static final int INITIAL_CAPACITY = 16; /** * The table, resized as necessary. table.length MUST always be a power * of two. */ private Entry[] table; /** * The number of entries in the table. */ private int size = 0; /** * The next size value at which to resize. */ private int threshold; // Default to 0 Entry繼承WeakReference，通過其注釋并結合WeakReference的功能，我們知道：一旦沒有指向 key 的強引用, ThreadLocalMap 在 GC 后將自動刪除相關的 entry。ThreadLocalMap采用數組來保存Entry，并且Entry中以ThreadLocal為key,初始大小為16. 接著看ThreadLocalMap的constructor: /** * Construct a new map initially containing (firstKey, firstValue). * ThreadLocalMaps are constructed lazily, so we only create one when we * have at least one entry to put in it. */ ThreadLocalMap(ThreadLocal firstKey, Object firstValue) { table = new Entry[INITIAL_CAPACITY]; int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1); table[i] = new Entry(firstKey, firstValue); size = 1; setThreshold(INITIAL_CAPACITY); } /** * Construct a new map including all Inheritable ThreadLocals from given * parent map. Called only by createInheritedMap. * * @param parentMap * the map associated with parent thread. */ private ThreadLocalMap(ThreadLocalMap parentMap) { Entry[] parentTable = parentMap.table; int len = parentTable.length; setThreshold(len); table = new Entry[len]; for (int j = 0; j < len; j++) { Entry e = parentTable[j]; if (e != null) { ThreadLocal key = e.get(); if (key != null) { Object value = key.childValue(e.value); Entry c = new Entry(key, value); int h = key.threadLocalHashCode & (len - 1); while (table[h] != null) h = nextIndex(h, len); table[h] = c; size++; } } } } ThreadLocalMap有兩個構造函數，可以直接傳入ThreadLcoal-value對，也可以傳入一個ThreadLocalMap,傳入ThreadLocalMap的時候，會依次將其Entry存放在table中。接著來分析get方法： /** * Get the entry associated with key. This method itself handles only * the fast path: a direct hit of existing key. It otherwise relays to * getEntryAfterMiss. This is designed to maximize performance for * direct hits, in part by making this method readily inlinable. * * @param key * the thread local object * @return the entry associated with key, or null if no such */ 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); } 通過實例變量threadLocalHashCode算出下標，然后返回其值。set和remove方法類似。 繼續(xù)看ThreadLocal類的get方法，通過getMap(Thread t)返回ThreadLocalMap，然后從ThreadLocalMap中通過getEntry(ThreadLocal key) 取出值。下面繼續(xù)看getMap(Thread t)方法： /** * Get the map associated with a ThreadLocal. Overridden in * InheritableThreadLocal. * * @param t * the current thread * @return the map */ ThreadLocalMap getMap(Thread t) { return t.threadLocals; } 可以看出其返回的是線程的一個實例變量。由此可知Thread類也持有ThreadLocalMap，這樣每個線程的變量都存放在自己的ThreadLocalMap中，可謂名符其實。 繼續(xù)看Thread類如何操作ThreadLocalMap： /* * ThreadLocal values pertaining to this thread. This map is maintained by * the ThreadLocal class. */ ThreadLocal.ThreadLocalMap threadLocals = null; /* * InheritableThreadLocal values pertaining to this thread. This map is * maintained by the InheritableThreadLocal class. */ ThreadLocal.ThreadLocalMap inheritableThreadLocals = null; Thread類中聲明了兩個ThreadLocalMap變量， /** * Initializes a Thread. * * @param g * the Thread group * @param target * the object whose run() method gets called * @param name * the name of the new Thread * @param stackSize * the desired stack size for the new thread, or zero to indicate * that this parameter is to be ignored. */ private void init(ThreadGroup g, Runnable target, String name, long stackSize) { Thread parent = currentThread(); SecurityManager security = System.getSecurityManager(); if (g == null) { /* Determine if it's an applet or not */ /* * If there is a security manager, ask the security manager what to * do. */ if (security != null) { g = security.getThreadGroup(); } /* * If the security doesn't have a strong opinion of the matter use * the parent thread group. */ if (g == null) { g = parent.getThreadGroup(); } } /* * checkAccess regardless of whether or not threadgroup is explicitly * passed in. */ g.checkAccess(); /* * Do we have the required permissions? */ if (security != null) { if (isCCLOverridden(getClass())) { security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION); } } g.addUnstarted(); this.group = g; this.daemon = parent.isDaemon(); this.priority = parent.getPriority(); this.name = name.toCharArray(); if (security == null || isCCLOverridden(parent.getClass())) this.contextClassLoader = parent.getContextClassLoader(); else this.contextClassLoader = parent.contextClassLoader; this.inheritedAccessControlContext = AccessController.getContext(); this.target = target; setPriority(priority); if (parent.inheritableThreadLocals != null) this.inheritableThreadLocals =ThreadLocal.createInheritedMap(parent.inheritableThreadLocals); /* Stash the specified stack size in case the VM cares */ this.stackSize = stackSize; /* Set thread ID */ tid = nextThreadID(); } 在init方法中，存在著對inheritableThreadLocals的操作： if (parent.inheritableThreadLocals != null) this.inheritableThreadLocals =ThreadLocal.createInheritedMap(parent.inheritableThreadLocals); 而ThreadLocal的createInheritedMap方法則是調用ThreadLocalMap類傳入ThreadLocalMap參數的構造函數。 也就是說在Thread類中，當前線程會調用init方法去初始一個線程，而在init方法中，會將當前線程的inheritableThreadLocals拷貝給等待初始化的線程。這讓我聯(lián)想起unix/linux系統(tǒng)中，父線程會調用fork()函數生成一個子線程，而且會把父線程大部分的信息拷貝給子線程。 最后來看Thread類的exit方法： /** * This method is called by the system to give a Thread a chance to clean up * before it actually exits. */ private void exit() { if (group != null) { group.remove(this); group = null; } /* Aggressively null out all reference fields: see bug 4006245 */ target = null; /* Speed the release of some of these resources */ threadLocals = null; inheritableThreadLocals = null; inheritedAccessControlContext = null; blocker = null; uncaughtExceptionHandler = null; } 在線程真正終止前會執(zhí)行這個方法，這個方法會把threadLocals和inheritableThreadLocals指向null。但我在Thread類中并沒有看到對threadLocals的賦值，應該是通過ThreadLocal來設置的。 寫了個簡單的Thread測試程序，只是想跟蹤一下上述兩個ThreadLocalMap變量的狀態(tài)： public class TimePrinter extends Thread { public void run() { while (true) { try { System.out.println(new Date(System.currentTimeMillis())); } catch (Exception e) { System.out.println(e); } } } static public void main(String args[]) { TimePrinter tp1 = new TimePrinter(); tp1.start(); ThreadLocal t2 = new ThreadLocal(); t2.set("aaaaaaaaaaaaaaaaaaaaaaaa"); } } 可以看到，啟動一個線程，不停打印系統(tǒng)時間，然后通過ThreadLocal給當前線程添加一份字符串，觀察有：   inheritableThreadLocals中有一個Entry,但value為null，threadLocals中有三個Entry,其中兩個value不明，一個為ThreadLocal設置的值。不過我實在不知道其他三個Entry值是如何設置的，留個疑問。 總結：ThreadLocal實例只有一個threadLocalHashCode值，ThreadLocal給各個線程設置的值都是存在各個線程threadLocals里 。相比Hashtable的實現方式，現在的方式更為合理。當一個線程終止時，其inheritableThreadLocals和threadLocals均被置為null,于是通過TreadLocal也就無法訪問這個線程；而當ThreadLocal被設置為null時，Thread里threadLocals就會移除key為ThreadLocal的Entry。Hashtable的實現方式則無法實現這一點。最為關鍵的是Hashtable的實現需要同步，所帶來的性能損耗是很大的，而現在的方式則不需要同步。性能提升很大。 |
|
|
