什么是ThreadLocal

Java doc的解释
ThreadLocal提供了线程局部可用的变量. 这些变量在每个线程中都维护有自己的独立副本. ThreadLocal类型的变量一般是一个类的静态变量来存储与线程相关的变量 (比如用户ID, 事务ID).

每个活的线程都持有thread-local变量的精确引用. 当线程terminated后, 该变量变得可以被GC(在没有其他引用后).

ThreadLocal可以做什么?

常见用途.

存储一些本身不是线程安全的类

比如SimpleDateFormat不是线程安全的, 我们可以用ThreadLocal来存储

import java.text.SimpleDateFormat;
import java.util.Date;

public class ThreadLocalDemo {


    static ThreadLocal<SimpleDateFormat> _formatter = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));


    public static String formate(Date date) {
        return _formatter.get().format(date);
    }

    public static void main(String[] args) {
        System.out.println(formate(new Date()));
    }

记录一些上下文相关的信息

比如前面写的userid, transactionid
我们用ThreadLocal来实现打印日志中包含正确的Component信息.

import java.util.Date;

public class ThreadLocalLooggerDemo {


    public static void main(String[] args) throws InterruptedException {

        Thread task = new Thread(new Runnable() {
            @Override
            public void run() {
                Log.setTaskId("Consumer");
                Log.info("I started");
                try {
                    Thread.sleep(1000);
                }
                catch (InterruptedException e) {
                }
                Log.info("I finished");
            }
        });
        task.start();
        task.join();
    }


    static class Log {
        static ThreadLocal<String> taskId = ThreadLocal.withInitial(() -> "N/A");
        public static void setTaskId(String taskIdStr) {
            taskId.set(taskIdStr);
        }

        public static String getTaskId() {
            return taskId.get();
        }


        public static void info(String message) {
            System.out.println(String.format("[%s][%s]%s", new Date(), taskId.get(), message));
        }
    }
}

示例输出

[Wed Jul 10 13:59:10 CST 2019][Consumer]I started
[Wed Jul 10 13:59:11 CST 2019][Consumer]I finished

实现细节

set 方法

        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            map.set(this, value);
        } else {
            createMap(t, value);
        }

每个Thread有一个自己的变量map: ThreadLocal.ThreadLocalMap threadLocals = null
该map是一个ThreadLocal内部定义的map. map里面的每个Entry都是WeakReference<ThreadLocal>.
使用WeakReference是因为我们不能一直持有一个Thread或者ThreadLocal的引用这会导致它没法被GC, 这就有了内存泄漏. 而WeakReference没有这个问题. 这就是后面如果Entry的key为NULL时, 它的值也被擦除了. (它的值就是这里的SimpleDateFormat)

int i = key.threadLocalHashCode & (len-1); // 根据key (threadlocal对象)找到tab[]的index

            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {  // 循环遍历 tab,   nextIndex  就是从i开始自增 并取模len
                ThreadLocal<?> k = e.get();

                if (k == key) {  // 如果是同一个对象 指针比较
                    e.value = value;  // 更新值返回
                    return;
                }

                if (k == null) {  // 当前位置没人用  就放在当前位置
                    replaceStaleEntry(key, value, i); // 该方法还会做一些动作 就是
                    return;
                }
            }

get方法

        Thread t = Thread.currentThread();  // 一直使用当前Thread的threadlocalmap
        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();  // 没有返回初始值 如果有设置的话

        private Entry getEntry(ThreadLocal<?> key) {
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
                return e; // 直接根据hash值找
            else
               // 没找到 或者不匹配
                return getEntryAfterMiss(key, i, e);
        }

        private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
            Entry[] tab = table;
            int len = tab.length;
			// 又是一个循环检查
            while (e != null) {
                ThreadLocal<?> k = e.get();
                if (k == key)
                    return e;
                if (k == null)
                    expungeStaleEntry(i);  // 擦除掉当前entry key为null的值, key和value都为NULL
                else
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }

// 擦除key为NULL的方法

        private int expungeStaleEntry(int staleSlot) {  // 当前key为null的slot
            Entry[] tab = table;
            int len = tab.length;

            // expunge entry at staleSlot  // 擦除当前slot
            tab[staleSlot].value = null;
            tab[staleSlot] = null;
            size--; 

            // Rehash until we encounter null
            Entry e;
            int i;
            // for 循环
            for (i = nextIndex(staleSlot, len); // 向下检查下一个slot
                 (e = tab[i]) != null;  // Entry有东西
                 i = nextIndex(i, len)) {
                ThreadLocal<?> k = e.get();
                if (k == null) {  // 擦除key 为null的   
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {
                    int h = k.threadLocalHashCode & (len - 1);
                    if (h != i) {
                        tab[i] = null;
                        // 擦除更多
                        // Unlike Knuth 6.4 Algorithm R, we must scan until
                        // null because multiple entries could have been stale.
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        tab[h] = e;
                    }
                }
            }
            return i;
        }

搞懂ThreadLocal

文章目录