ThreadLocal的用法

青旅半醒 2022-09-19 08:22 45阅读 0赞

使用ThreadLocal是维持线程封闭的一种更规范的方法。通过ThreadLocal的set方法，使每个线程都拥有自己线程内的对象，**其他线程是不需要访问的，也访问不到的**，这样的就不产生多个线程共同使用一个对象的问题。

ThreadLocal的一个典型应用场景是当你想在各个线程中访问一些非线程安全的对象，但又不想用synchronized或lock等同步机制。

但注意，set进去的对象必须是调用着自己创建的，并且需要自己保证跟其他set进去的对象不是相同的引用。如果ThreadLocal.set()进去的东西本来就是多个线程共享的同一个对象，那么多个线程的ThreadLocal.get()取得的还是这个共享对象本身，还是有并发访问问题。

在J2EE中使用ThreadLocal要注意内存泄漏导致outofMemory问题，可参见：http://www.pixelstech.net/article/1399361023-Use-ThreadLocal-with-caution

hibernate中典型的ThreadLocal的应用：

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();  //如果没有，就打开一个新的session
                    threadSession.set(s);  
                }  
            } catch (HibernateException ex) {  
                throw new InfrastructureException(ex);  
            }  
            return s;  
        }

原理：通过ThreadLocal.set()会将对象的引用保存到该线程本身自带一个map中（实际是放到当前线程的ThreadLocalMap中），执行ThreadLocal.get()时，各线程从自己的ThreadLocalMap中取出对象，因此取出来的是各自自己线程中的对象，ThreadLocal实例是作为map的key来使用的。

试想如果不用ThreadLocal怎么来实现呢？可能就要在action中创建session，然后把session一个个传到service和dao中。或者可以自己定义一个静态的map，将当前thread作为key，创建的session作为值，put到map中。

所以，使用ThreadLocal的好处是为调用的客户屏蔽这些复杂度，使线程对象管理在类内部完成。

看看ThreadLocal的源码

ublic class ThreadLocal<T> {  
        /** 
         * ThreadLocals rely on per-thread 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. Accessed only by like-named method. 
         */  
        private static int nextHashCode = 0;  
      
        /** 
         * 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;  
      
        /** 
         * Compute the next hash code. The static synchronization used here 
         * should not be a performance bottleneck. When ThreadLocals are 
         * generated in different threads at a fast enough rate to regularly 
         * contend on this lock, memory contention is by far a more serious 
         * problem than lock contention. 
         */  
        private static synchronized int nextHashCode() {  
            int h = nextHashCode;  
            nextHashCode = h + HASH_INCREMENT;  
            return h;  
        }  
      
        /** 
         * Creates a thread local variable. 
         */  
        public ThreadLocal() {  
        }  
      
        /** 
         * Returns the value in the current thread's copy of this thread-local 
         * variable.  Creates and initializes the copy if this is the first time 
         * the thread has called this 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)  
                return (T)map.get(this);  
      
            // Maps are constructed lazily.  if the map for this thread  
            // doesn't exist, create it, with this ThreadLocal and its  
            // initial value as its only entry.  
            T value = initialValue();  
            createMap(t, value);  
            return value;  
        }  
      
        /** 
         * Sets the current thread's copy of this thread-local variable 
         * to the specified value.  Many applications will have no need for 
         * this functionality, relying solely on the {@link #initialValue} 
         * method to set the values of thread-locals. 
         * 
         * @param value the value to be stored in the current threads' copy of 
         *        this thread-local. 
         */  
        public void set(T value) {  
            Thread t = Thread.currentThread();  
            ThreadLocalMap map = getMap(t);  
            if (map != null)  
                map.set(this, value);  
            else  
                createMap(t, value);  
        }  
      
        /** 
         * 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;  
        }  
      
        /** 
         * Create the map associated with a ThreadLocal. Overridden in 
         * InheritableThreadLocal. 
         * 
         * @param t the current thread 
         * @param firstValue value for the initial entry of the map 
         * @param map the map to store. 
         */  
        void createMap(Thread t, T firstValue) {  
            t.threadLocals = new ThreadLocalMap(this, firstValue);  
        }  
      
        .......  
      
        /** 
         * 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 {  
      
        ........  
      
        }  
      
    }