ThreadLocal的使用

 引言

　　在高并发的情况下，线程安全是尤其重要的，其中线程安全又分为多个方面，安全发布对象、不可变对象、线程封闭等。其中，线程封闭就是将变量封装到一个线程中， 这样并发的其他线程就无法看到和使用该变量，这样就保证了线程的安全性。而线程封闭的其中一种就是使用ThreadLocal,这在我们实际开发中也是非常有用的。

ThreadLocal介绍

　　ThreadLocal主要是通过以Map的形式对数据进行存储，其中 key为当前线程，而value值是我们传入的参数；使用ThreadLocal可以让我们的代码更简洁，并且在想使用我们存储数据的任何地方都可以拿到。最重要的是它是线程封闭的，也就是线程安全的，适用于在多线程场合。

ThreadLocal部分源码

    ThreadLocal最常用的3个方法，一、设置值，二、取出值，三、清空值（请及时清空，以免发生内存溢出的情况）

设置值

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

取出值

    public T get() {
        Thread t = Thread.currentThread();
        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();
    }

清空值

    public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

使用场景

通常情况下，都是结合过滤器和拦截器进行使用，在过滤器时存值，然后在接口执行结束时清空值

实例

以springboot中使用ThreadLocal为例

定义ThreadLocal操作类

 1 package com.me.concurrency.threadlocal;
 2 
 3 public class RequestHolder {
 4 
 5     private static ThreadLocal<Long> threadId = new ThreadLocal<>();
 6 
 7     public static void add(Long id) {
 8         threadId.set(id);
 9     }
10 
11     public static void remove() {
12         threadId.remove();
13     }
14 
15     public static Long get() {
16         return threadId.get();
17     }
18 
19 
20 }

定义过滤器

package com.me.concurrency.threadlocal;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@Slf4j
public class HttpFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        log.info("currentThreadId --{}", Thread.currentThread().getId());
        log.info("the request url is:{}", request.getRequestURL());
        RequestHolder.add(Thread.currentThread().getId());
        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override
    public void destroy() {

    }
}

定义拦截器

package com.me.concurrency.threadlocal;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Slf4j
public class CustomInterceptor extends HandlerInterceptorAdapter {

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

    // 正常结束
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        super.postHandle(request, response, handler, modelAndView);
    }

    // 正常与异常结束
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        log.info("interceptor compeleted..");
        RequestHolder.remove();
    }


}

springboot中过滤器和拦截器的配置

package com.me.concurrency.config;

import com.me.concurrency.threadlocal.CustomInterceptor;
import com.me.concurrency.threadlocal.HttpFilter;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Configuration
public class WebMvcConfig extends WebMvcConfigurerAdapter {


    @Bean
    public FilterRegistrationBean httpFilter() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        filterRegistrationBean.setFilter(new HttpFilter());
        filterRegistrationBean.addUrlPatterns("/threadLocal/*"); // 过滤的请求
        return filterRegistrationBean;
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new CustomInterceptor()).addPathPatterns("/threadLocal/**"); //拦截的请求
    }
}

测试接口

@RequestMapping("/threadLocal/getId")
    @ResponseBody
    public Long threadLocal(){
        return RequestHolder.get();
    }

执行结果

写在最后

ThreadLocal在项目中的使用非常常见，它能将我们需要存储的值以key为当前线程，value为实际存储值的形式存储在map的数据结构中，并且对存储的值进行了线程封闭，其他线程是不能看到和使用的，所以是线程安全的，适用于多线程，高并发的场景下；而且，使用ThreadLocal可以简化我们的代码，我们不需要将存储值一层一层的传递下去，而是在任何地方直接通过ThreadLocal取到值。