ThreadLocal

灰太狼 2021-04-19 14:14 526阅读 0赞

# 是什么 #

顾名思义，线程本地类。

# 作用 #

在多线程环境下，每个线程都有一个副本。

如果是普通数据，那么所有线程操作的都是同一份数据，会出现线程同步的问题。

所以，每个线程都有一个副本的好处就是避免线程同步的问题。

# 应用场景 #

每个线程都有自己的数据，而不是多线程之间共享这个数据。

1.userId  
2.transactionId  
3.threadId

# 具体怎么使用 #

//jdk7-API官方文档
    import java.util.concurrent.atomic.AtomicInteger;
    
    //获取线程id：不是系统默认的线程id，是自定义线程id
     public class ThreadId {
         // Atomic integer containing the next thread ID to be assigned
         private static final AtomicInteger nextId = new AtomicInteger(0); //初始值是0
    
         // Thread local variable containing each thread's ID private static final ThreadLocal<Integer> threadId = new ThreadLocal<Integer>() { //匿名对象 @Override protected Integer initialValue() { return nextId.getAndIncrement(); //第一个线程调用的时候，得到的值是1；第二个线程调用的时候，得到的值是2；后面以此类推 } }; // Returns the current thread's unique ID, assigning it if necessary
         public static int get() { //获取当前线程的线程id
             return threadId.get(); //每个线程第一次调用ThreadLocal.get()方法时，因为没有初始值，所以都会调用initialValue()方法，得到一个初始值
         }
     }

总结  
1.类  
自定义工具类

2.类包含了线程本地数据  
确保每个线程都有自己的副本数据。//数据属于每个线程自己

3.每个线程获取数据的时候，是通过线程安全的方法去获取数据的 比如，使用并发包-原子类。这样就确保了获取的数据是唯一的。//数据唯一性

# 底层实现 #

第一次获取值  
第一次调用get()方法获取值的时候，会调用initialValue()方法。所以，一般需要重写initialValue()方法。

//jdk7-ThreadLocal
    /**
         * 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) { //第一次调用get()，map为null
                ThreadLocalMap.Entry e = map.getEntry(this);
                if (e != null)
                    return (T)e.value;
            }
            return setInitialValue(); //第一次调用get()，会调用初始化方法initialValue()得到一个初始值
        }
        
        /**
         * Variant of set() to establish initialValue. Used instead
         * of set() in case user has overridden the set() method.
         *
         * @return the initial value
         */
        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;
        }
        
        /**
         * Returns the current thread's "initial value" for this * thread-local variable. This method will be invoked the first * time a thread accesses the variable with the {@link #get} * method, unless the thread previously invoked the {@link #set} * method, in which case the <tt>initialValue</tt> method will not * be invoked for the thread. Normally, this method is invoked at * most once per thread, but it may be invoked again in case of * subsequent invocations of {@link #remove} followed by {@link #get}. * * <p>This implementation simply returns <tt>null</tt>; if the * programmer desires thread-local variables to have an initial * value other than <tt>null</tt>, <tt>ThreadLocal</tt> must be * subclassed, and this method overridden. Typically, an * anonymous inner class will be used. * * @return the initial value for this thread-local */ 
		 protected T initialValue() { 
			 return null; 
			 //默认的初始化方法，值是null。所以需要重写。 
		 }

--------------------

数据保存在哪里？  
有一个数据保存每个线程自己的数据。这个数据使用的数据结构是映射map，jdk自定义了一个新的映射map-ThreadLocalMap。

这个map与其他jdk-map类不同的地方在于，  
1.在哪里？  
这个map类是在ThreadLocal里面，也就是说，这个数据是与每个线程紧密相关的，只是供内部使用。  
2.key？  
基于1的原因，导致ThreadLocalMap实现的时候，它的key是什么呢？是线程本身吗？或者换个问法：

为什么不用个全局的map来实现threadlocal，key为当前threalocal+thread，value为其对应的值。毕竟这个实现简单又易于理解。

这里涉及到对象回收的问题。

所以，jdk使用的是哪一种解决方案呢？ 1》Thread.map map就是ThreadLocalMap。我们说，每个线程都有自己的数据，为什么这么说呢？原因就在于每个线程都有一个自己的数据ThreadLocalMap。ThreadLocalMap存放了真正的数据value。

2》map(ThreadLocal,value) key是ThreadLocal，而ThreadLocal是final，系统全局唯一，即所有线程使用的是同一个key。同一个key，那怎么找到对应线程自己的数据？虽然key是一样的，但是map不一样，这里说的不一样，是说每个线程都有自己的map，每个线程取数据的时候，也是分2步：1.先取自己线程的map 2.再取map的value。所以哪怕key一样，也没有关系。

/**
         * 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) { //键是线程本身ThreadLocal
                    super(k);
                    value = v;
                }
            }
            
        
        /**
             * Set the value associated with key.
             *
             * @param key the thread local object
             * @param value the value to be set
             */
            private void set(ThreadLocal key, Object value) { //写方法
    
                // We don't use a fast path as with get() because it is at // least as common to use set() to create new entries as // it is to replace existing ones, in which case, a fast // path would fail more often than not. Entry[] tab = table; int len = tab.length; int i = key.threadLocalHashCode & (len-1); for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) { ThreadLocal k = e.get(); if (k == key) { e.value = value; return; } if (k == null) { replaceStaleEntry(key, value, i); return; } } tab[i] = new Entry(key, value); int sz = ++size; if (!cleanSomeSlots(i, sz) && sz >= threshold) rehash(); } /** * 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); }

# 工作应用 #

支付

--------------------