public class UserContextHolder {

    private static ThreadLocal<MemberRespVo> memberRespVoContext = new ThreadLocal<>();

    // Set the user information if it not null.
    public static void setCurrentUser(MemberRespVo memberRespVo) {
        // ThreadLocal is thread-local variable, therefore it hasn't concurrent problem.
        // Each thread call the threadLocal.get is get different result.
        if (memberRespVoContext.get() == null) {
            memberRespVoContext.set(memberRespVo);
        }
    }
    
    // Get current user information.
    public static MemberRespVo getCurrentUser() {
        return memberRespVoContext.get();
    }

    // Remove current user information from ThreadLocal.
    public static void removeCurrentUser() {
        memberRespVoContext.remove();
    }
}

public class LoginUserInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        MemberRespVo memberRespVo = (MemberRespVo) request.getSession().getAttribute(PlatformAuthConstant.LOGIN_USER);
        if (memberRespVo == null) {
            // hasn't login, redirect to login page.
            response.sendRedirect("http://auth.platform.com/login.html");
            return false;
        } else {
            UserContextHolder.setCurrentUser(memberRespVo);
            return true;
        }
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        // threadLocal.remove();
    }


    /**
     * Remove ther user infomation in ThreadLocal when complete of request processing and view rendering.
     * Why not remove in postHandle ?
     * https://stackoverflow.com/questions/37358426/remove-threadlocal-object-within-a-spring-mvc-website
     * The postHandle method looks like a good place, but afterCompletion is better because it's called
     * even when the handler fails to process the request correctly (aka an exception occurred).
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        UserContextHolder.removeCurrentUser();
    }
}

public class ThreadLocalAwareThreadPool extends ThreadPoolExecutor {
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        // Call remove on each ThreadLocal
    }
}

public abstract class RequestContextHolder  {

	private static final boolean jsfPresent =
			ClassUtils.isPresent("javax.faces.context.FacesContext", RequestContextHolder.class.getClassLoader());

	private static final ThreadLocal<RequestAttributes> requestAttributesHolder =
			new NamedThreadLocal<>("Request attributes");

	private static final ThreadLocal<RequestAttributes> inheritableRequestAttributesHolder =
			new NamedInheritableThreadLocal<>("Request context");


	/**
	 * Reset the RequestAttributes for the current thread.
	 */
	public static void resetRequestAttributes() {
		requestAttributesHolder.remove();
		inheritableRequestAttributesHolder.remove();
	}

	/**
	 * Bind the given RequestAttributes to the current thread,
	 */
	public static void setRequestAttributes(@Nullable RequestAttributes attributes) {
		setRequestAttributes(attributes, false);
	}

	/**
	 * Bind the given RequestAttributes to the current thread.
	 */
	public static void setRequestAttributes(@Nullable RequestAttributes attributes, boolean inheritable) {
		if (attributes == null) {
			resetRequestAttributes();
		}
		else {
			if (inheritable) {
				inheritableRequestAttributesHolder.set(attributes);
				requestAttributesHolder.remove();
			}
			else {
				requestAttributesHolder.set(attributes);
				inheritableRequestAttributesHolder.remove();
			}
		}
	}

	/**
	 * Return the RequestAttributes currently bound to the thread.
	 */
	@Nullable
	public static RequestAttributes getRequestAttributes() {
		RequestAttributes attributes = requestAttributesHolder.get();
		if (attributes == null) {
			attributes = inheritableRequestAttributesHolder.get();
		}
		return attributes;
	}

	/**
	 * Return the RequestAttributes currently bound to the thread.
	 */
	public static RequestAttributes currentRequestAttributes() throws IllegalStateException {
		RequestAttributes attributes = getRequestAttributes();
		if (attributes == null) {
			if (jsfPresent) {
				attributes = FacesRequestAttributesFactory.getFacesRequestAttributes();
			}
			if (attributes == null) {
				throw new IllegalStateException("No thread-bound request found...");
			}
		}
		return attributes;
	}
	// ...
}

// 当前ThreadLocal的hashCode，通过 nextHashCode()运算得到，被用来计算当前ThreadLocal在ThreadLocalMap中的位置
private final int threadLocalHashCode = nextHashCode();
// 哈希魔数，主要与斐波那契哈希和黄金分割有关
private static final int HASH_INCREMENT = 0x61c88647;
// 返回计算得到的下一个哈希值, i * HASH_INCREMENT, i 代表调用的次数
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}
// 确保同一台机器中的不同ThreadLocal的threadLocalHashCode具有唯一性
private static AtomicInteger nextHashCode = new AtomicInteger();

static class ThreadLocalMap {
	/**
	 * Storage structure of key value to entity
	 */
	static class Entry extends WeakReference<ThreadLocal<?>> {
		// value与当前线程对应,不被弱引用追踪
		Object value;

		/**
		 * 键值对构造器
		 * key，ThreadLocal中的key被包装为弱引用
		 * v，值
		 */
		Entry(ThreadLocal<?> k, Object v) {
			super(k);
			value = v;
		}
	}

	// 初始容量，一定为2的n次幂
	private static final int INITIAL_CAPACITY = 16;

	// 保存实体键值对的数组，长度一定为2的次幂
	private Entry[] table;

	// ThreadLocalMap中元素个数
	private int size = 0;

	// 扩展临界值, 默认为数组长度的2/3
	private int threshold;
}

// 清理与当前ThreadLocal保存的的键值对
public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

public void set(T value) {      // 设置一个值
    Thread t = Thread.currentThread();  // 获取当前线程
    ThreadLocalMap map = getMap(t);     // 通过线程获取到线程绑定的ThreadLocalMap
    if (map != null)                    // map可能未被创建
        map.set(this, value);           // 直接设置
    else
        createMap(t, value);           // 将其创建并将当前值设置进去
}

ThreadLocalMap getMap(Thread t) {   // 获取线程的threadLocals属性(ThreadLocalMap)
    return t.threadLocals;
}

/* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;

// 将键值对保存到map中
private void set(ThreadLocal<?> key, Object value) {
	Entry[] tab = table;
	int len = tab.length;
	// 计算key在数组中的下标
	int i = key.threadLocalHashCode & (len - 1);
	// 采用线性探索查找出空闲的位置
	for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
		// 获取元素的hash值
		ThreadLocal<?> k = e.get();

		// 如果ThreadLocal的key匹配，直接改变map中的值
		if (k == key) {
			e.value = value;
			return;
		}

		// 如果key为null，表明key被清除，可以直接替换
		if (k == null) {
			replaceStaleEntry(key, value, i);
			return;
		}
	}

	// 在遇到空插槽之前，找不到匹配的ThreadLocal对象。将ThreadLocal对象和缓存的值排列在空插槽中
	tab[i] = new Entry(key, value);
	int sz = ++size;
	//  如果没有元素被清理，检查当前数组的容量是否差错扩展临界值，以此来考虑是否需要扩展。
	if (!cleanSomeSlots(i, sz) && sz >= threshold) {
		rehash();
	}
}

public T get() {
	Thread t = Thread.currentThread();
	ThreadLocalMap map = getMap(t);
	if (map != null) {
        // 尝试从map中获取Entry
		ThreadLocalMap.Entry e = map.getEntry(this);
		if (e != null) {
			@SuppressWarnings("unchecked")
			T result = (T) e.value;
			return result;
		}
	}
	// 如果map为null，初始化当前线程的ThreadLocalMap,最后返回与当前ThreadLocal对象关联的初始值
	return setInitialValue();
}

private Entry getEntry(ThreadLocal<?> key) {
    // 运算获取下标
	int i = key.threadLocalHashCode & (table.length - 1);
	Entry e = table[i];
	// 如果e不为空，而且e对一个拿到key与传入的相同，表示正是要找的，直接返回
	if (e != null && e.get() == key) {
		return e;
	} else {
		// 如果key不相等或者e为null，从i开始先后探索查找
		return getEntryAfterMiss(key, i, e);
	}
}

private void resize() {
	Entry[] oldTab = table;
	int oldLen = oldTab.length;
	int newLen = oldLen * 2;
	// 创建一个新的数组，长度为原来的2倍
	Entry[] newTab = new Entry[newLen];
	int count = 0;

	// 从旧数组中将值复制到新数组
	for (int j = 0; j < oldLen; ++j) {
		Entry e = oldTab[j];
		if (e != null) {
			ThreadLocal<?> k = e.get();
			// 如果发现一个k以及为null，即为垃圾值，直接将value的引用就行清除，以便其可以被GC回收
			if (k == null) {
				e.value = null;
			} else {
				// 计算ThreadLocal在Map的新位置
				int h = k.threadLocalHashCode & (newLen - 1);
				// 如果发生了冲突，使用线性探索寻找合适的位置
				while (newTab[h] != null) {
					h = nextIndex(h, newLen);
				}
				newTab[h] = e;
				count++;
			}
		}
	}
	// 设置新的size，临界长度
	setThreshold(newLen);
	size = count;
	table = newTab;
}