上一节介绍了不可变对象，通过在某些情况下将不会修改的类对象设计成不可变对象，来让对象在多个线程间保证对象是线程安全的。归根到底，相当于躲避开了并发问题，实现好的并发是一件很困难的事情，所以很多时候都想躲避并发，避免并发除了设计成不可变对象其实还有一个简单的方法就是线程封闭。
什么是线程封闭？
其实就是把对象封装到一个线程里，只有这一个线程能看到这个对象。那么这个对象就算不是线程安全的，也不会出现线程安全方面的问题了，因为他只能在一个线程里面进行访问。那么如何实现线程封闭呢？
如何实现线程封闭？
- Ad-hoc 线程封闭：程序控制实现，最糟糕，忽略
- 堆栈封闭：局部变量，无并发问题。是我们现实中使用最多的封闭了，简单说就是局部变量。多个线程访问一个方法的时候，方法中的局部变量都会被拷贝一份到线程栈中，所以局部变量是不会被线程共享的，因此不会出现并发问题。所以全局变量容易引起并发问题。
- ThreadLocal线程封闭：特别好的封闭方法。ThreadLocal内部维护了一个map，key是线程的名称，value就是封闭的对象。
ThreadLocal
正常来讲我们每一个请求对服务器来讲都是一个线程在运行，我们希望线程间隔离，一个线程在被后端服务器实际处理的时候，可以通过Filter过滤器取出当前的用户，然后将数据存放在ThreadLocal中，当线程被接口的service以及其他相关类进行处理的时候很可能需要在取出当前用户，这时就可以随时随地从ThreadLocal中直接拿到之前存储的值这样用起来就很方便了。如果我们不这样做，会有什么麻烦呢？因为我们的登录用户通常是从request中取出来的，因此需要带上request或者从request中取出来的用户信息，从controller层开始不停的往下传，甚至会传到一些util类中，这样会使得代码看起来很臃肿。当使用ThreadLocal和Filter，就可以很方便的在接口处理之前，前取出相关的信息，在接口实际处理的时候，什么时候需要什么时候再把信息取出来，这样代码在设计的时候就容易多了，不至于把request从controller一直传递下去。
具体使用实例如下：
新建一个类：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
2 //因为当前没有登录用户，我们用线程id来充当
3 private final static ThreadLocal<Long> requestHolder = new ThreadLocal<>();
4
5 /**
6 * 请求进入到后端服务器，但是还没有实际处理的时候调用add，可以使用Filter
7 * @param id
8 */
9 public static void add(Long id) {
10 //虽然只传入id，但是threadLocal会取出当前线程id放到map中的key，value是传入的值
11 requestHolder.set(id);
12 }
13
14 public static Long getId() {
15 return requestHolder.get();
16 }
17
18 /**
19 * 如果不做remove的话，会造成内存泄漏，数据永远不会释放掉
20 * 需要在接口真正处理完成之后进行调用，可以使用interceptor
21 */
22 public static void remove() {
23 requestHolder.remove();
24 }
25}
26
这个类就用来存放ThreadLocal。
新建一个Filter：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
2public class HttpFilter implements Filter {
3 @Override
4 public void init(FilterConfig filterConfig) throws ServletException {
5
6 }
7
8 @Override
9 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
10 HttpServletRequest httpServletRequest = (HttpServletRequest) request;
11// httpServletRequest.getSession().getAttribute("user");
12 log.info("do filter , {}, {}", Thread.currentThread().getId(), ((HttpServletRequest) request).getServletPath());
13 RequestHolder.add(Thread.currentThread().getId());
14 // 如果这个Filter不想拦截住这个请求，只想做单独的数据处理时，要调用chain.doFilter,使得拦截器处理完
15 chain.doFilter(request, response);
16 }
17
18 @Override
19 public void destroy() {
20
21 }
22}
23
24
新建一个Interceptor：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
2public class HttpInterceptor extends HandlerInterceptorAdapter {
3 @Override
4 public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
5 log.info("preHandle");
6 return true;
7 }
8
9 @Override
10 public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
11 RequestHolder.remove();
12 log.info("afterCompletion");
13 return ;
14 }
15}
16
17
配置filter和interceptor：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2public class Config implements WebMvcConfigurer {
3
4 @Bean
5 public FilterRegistrationBean<HttpFilter> httpFilter(){
6 FilterRegistrationBean<HttpFilter> filterRegistrationBean = new FilterRegistrationBean<>();
7 // 设置filter
8 filterRegistrationBean.setFilter(new HttpFilter());
9 // 拦截规则
10 filterRegistrationBean.addUrlPatterns("/threadLocal/*");
11 return filterRegistrationBean;
12 }
13
14 @Override
15 public void addInterceptors(InterceptorRegistry registry) {
16 registry.addInterceptor(new HttpInterceptor()).addPathPatterns("/**");
17 }
18}
19
20
新建一个controller进行测试：
2
3
4
5
6
7
8
9
10
11
2@RequestMapping("threadLocal")
3public class ThreadLocalController {
4
5 @GetMapping("/test")
6 public Long test() {
7 return RequestHolder.getId();
8 }
9
10}
11
在浏览器中输入localhost:8080/threadLocal/test可以输出线程的id，与后台的输出id一致。
