深入理解 ThreadLocal：拨开迷雾，探究本质

public class ThreadLocalUsage01 {
    public static void main(String[] args) {        new Thread(new Runnable() {            @Override            public void run() {                String date = new ThreadLocalUsage01().date(10);                System.out.println(date);            }        }).start();
        new Thread(new Runnable() {            @Override            public void run() {                String date = new ThreadLocalUsage01().date(1000);                System.out.println(date);            }        }).start();    }
    private String date(int seconds) {        // 参数的单位是毫秒，从1970.1.1 00:00:00 GMT计时        Date date = new Date(1000 * seconds);        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");        return dateFormat.format(date);    }
}

public class ThreadLocalUsage02 {
    public static ExecutorService THREAD_POOL = Executors.newFixedThreadPool(10);    static SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    public static void main(String[] args) throws InterruptedException {        for (int i = 0; i < 1000; i++) {            int finalI = i;            THREAD_POOL.submit(new Runnable() {                @Override                public void run() {                    String date = new ThreadLocalUsage02().date(finalI);                    System.out.println(date);                }            });        }        // 关闭线程池，此种关闭方式不再接受新的任务提交，等待现有队列中的任务全部执行完毕之后关闭        THREAD_POOL.shutdown();    }
    private String date(int seconds) {        // 参数的单位是毫秒，从1970.1.1 00:00:00 GMT计时        Date date = new Date(1000 * seconds);        return DATE_FORMAT.format(date);    }
}

private String date(int seconds) {    // 参数的单位是毫秒，从1970.1.1 00:00:00 GMT计时    Date date = new Date(1000 * seconds);    String format;    synchronized (ThreadLocalUsage02.class) {        format = DATE_FORMAT.format(date);    }    return format;}

public class ThreadLocalUsage04 {
    public static ExecutorService THREAD_POOL = Executors.newFixedThreadPool(10);
    public static void main(String[] args) throws InterruptedException {        for (int i = 0; i < 1000; i++) {            int finalI = i;            THREAD_POOL.submit(new Runnable() {                @Override                public void run() {                    String date = new ThreadLocalUsage04().date(finalI);                    System.out.println(date);                }            });        }        THREAD_POOL.shutdown();    }
    private String date(int seconds) {        // 参数的单位是毫秒，从1970.1.1 00:00:00 GMT计时        Date date = new Date(1000 * seconds);        SimpleDateFormat simpleDateFormat = ThreadSafeDateFormatter.dateFormatThreadLocal.get();        return simpleDateFormat.format(date);    }
}
class ThreadSafeDateFormatter {
    public static ThreadLocal<SimpleDateFormat> dateFormatThreadLocal = new ThreadLocal<SimpleDateFormat>() {        @Override        protected SimpleDateFormat initialValue() {            return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");        }    };
}

public class ThreadLocalUsage05 {
    public static void main(String[] args) {        Student student = init();        new NameService().getName(student);        new SexService().getSex(student);        new ScoreService().getScore(student);    }
    private static Student init() {        Student student = new Student();        student.name = "Lemon";        student.sex = "female";        student.score = "100";        return student;    }
}
class Student {
    /**     * 姓名、性别、成绩     */    String name;    String sex;    String score;
}
class NameService {
    public void getName(Student student) {        System.out.println(student.name);    }
}
class SexService {
    public void getSex(Student student) {        System.out.println(student.sex);    }
}
class ScoreService {
    public void getScore(Student student) {        System.out.println(student.score);    }
}

public class ThreadLocalUsage05 {
    public static void main(String[] args) {        init();        new NameService().getName();        new SexService().getSex();        new ScoreService().getScore();    }
    private static void init() {        Student student = new Student();        student.name = "Lemon";        student.sex = "female";        student.score = "100";        ThreadLocalProcessor.studentThreadLocal.set(student);    }
}
class ThreadLocalProcessor {
    public static ThreadLocal<Student> studentThreadLocal = new ThreadLocal<>();
}
class Student {
    /**     * 姓名、性别、成绩     */    String name;    String sex;    String score;
}
class NameService {
    public void getName() {        System.out.println(ThreadLocalProcessor.studentThreadLocal.get().name);    }
}
class SexService {
    public void getSex() {        System.out.println(ThreadLocalProcessor.studentThreadLocal.get().sex);    }
}
class ScoreService {
    public void getScore() {        System.out.println(ThreadLocalProcessor.studentThreadLocal.get().score);    }
}

static class Entry extends WeakReference<ThreadLocal<?>> {    /** The value associated with this ThreadLocal. */    Object value;
    Entry(ThreadLocal<?> k, Object v) {        super(k);        value = v;    }}

// 默认的数组初始化容量private static final int INITIAL_CAPACITY = 16;// Entry数组，大小必须为2的幂private Entry[] table;// 数组内部元素个数private int size = 0;// 数组扩容阈值，默认为0，创建了ThreadLocalMap对象后会被重新设置private int threshold;

/** * 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) {	// 初始化Entry数组，大小 16    table = new Entry[INITIAL_CAPACITY];    // 用第一个键的哈希值对初始大小取模得到索引，和HashMap的位运算代替取模原理一样    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);    // 将Entry对象存入数组指定位置    table[i] = new Entry(firstKey, firstValue);    size = 1;    // 初始化扩容阈值，第一次设置为10    setThreshold(INITIAL_CAPACITY);}

public void set(T value) {	// 首先获取调用此方法的线程    Thread t = Thread.currentThread();    // 将线程传递到getMap方法中来获取ThreadLocalMap，其实就是获取到当前线程的成员变量threadLocals所指向的ThreadLocalMap对象    ThreadLocalMap map = getMap(t);    // 判断Map是否为空    if (map != null)    	// 如果Map为不空，说明当前线程内部已经有ThreadLocalMap对象了，那么直接将本ThreadLocal对象作为键，存入的value作为值存储到ThreadLocalMap中        map.set(this, value);    else    	// 创建一个ThreadLocalMap对象并将值存入到该对象中，并赋值给当前线程的threadLocals成员变量        createMap(t, value);}
// 获取到当前线程的成员变量threadLocals所指向的ThreadLocalMap对象ThreadLocalMap getMap(Thread t) {	return t.threadLocals;}
// 创建一个ThreadLocalMap对象并将值存入到该对象中，并赋值给当前线程的threadLocals成员变量void createMap(Thread t, T firstValue) {    t.threadLocals = new ThreadLocalMap(this, firstValue);}

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;    // 计算当前ThreadLocal对象作为键在Entry数组中的下标索引    int i = key.threadLocalHashCode & (len-1);
	// 线性遍历，首先获取到指定下标的Entry对象，如果不为空，则进入到for循环体内，	// 判断当前的ThreadLocal对象是否是同一个对象，如果是，那么直接进行值替换，并结束方法，	// 如果不是，再判断当前Entry的key是否失效，如果失效，则直接将失效的key和值进行替换。	// 这两点都不满足的话，那么就调用nextIndex方法进行搜寻下一个合适的位置，进行同样的操作，	// 直到找到某个位置，内部数据为空，也就是Entry为null，那么就直接将键值对设置到这个位置上。	// 最后判断是否达到了扩容的条件，如果达到了，那么就进行扩容。    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();}

private static int nextIndex(int i, int len) {    return ((i + 1 < len) ? i + 1 : 0);}

public T get() {	// 获取当前线程的ThreadLocalMap对象    Thread t = Thread.currentThread();    ThreadLocalMap map = getMap(t);    if (map != null) {   		// 如果map不为空，那么尝试获取Entry数组中以当前ThreadLocal对象为键的Entry对象        ThreadLocalMap.Entry e = map.getEntry(this);        if (e != null) {        	// 如果找到，那么直接返回value            @SuppressWarnings("unchecked")            T result = (T)e.value;            return result;        }    }    // 如果Map为空或者在Entry数组中没有找到以当前ThreadLocal对象为键的Entry对象，    // 那么就在这里进行值初始化，值初始化的过程是将null作为值，当前ThreadLocal对象作为键，    // 存入到当前线程的ThreadLocalMap对象中    return setInitialValue();}
// 值初始化过程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;}

public void remove() {    ThreadLocalMap m = getMap(Thread.currentThread());    if (m != null)        m.remove(this);}
// 具体的删除指定的值，也是通过遍历寻找，找到就删除，找不到就算了private void remove(ThreadLocal<?> key) {    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)]) {        if (e.get() == key) {            e.clear();            expungeStaleEntry(i);            return;        }    }}

static class Entry extends WeakReference<ThreadLocal<?>> {    /** The value associated with this ThreadLocal. */    Object value;
    Entry(ThreadLocal<?> k, Object v) {        super(k);        value = v;    }}