先描述一下当时的场景，有一个需求，需要根据员工编号查询两万员工的信息，但是要去另一个微服务查询，所以使用feign的方式请求接口，但是一次查询两万个员工响应速度很慢，所以想要分几个线程请求接口，这里使用JDK1.7提供的多线程并发处理框架ForkJoin。代码是这样的：
// ForkJoin任务
private class MyRecursiveTask extends RecursiveTask<List<UserDTO>> {
private final List<String> empCodeList;
public MyRecursiveTask(List<String> empCodeList){
this.empCodeList = empCodeList;
}
@Override
protected List<UserDTO> compute() {
// 如果list的长度小于阈值就执行查询操作，反之将list二分
if(empCodeList.size() <= threshold){
// 执行查询
QueryEmployeeDTO queryEmployeeDTO = new QueryEmployeeDTO();
queryEmployeeDTO.setEmpCodes(empCodeList);
List<EmployeeVO> empList = thirdPartyApi.getEmpList(queryEmployeeDTO);
// 转换DTO对象
List<UserDTO> userDTOList = new ArrayList<>();
for (EmployeeVO emp : empList) {
userDTOList.add(new UserDTO(String.valueOf(emp.getId()),emp.getEmpName(),emp.getEmpNo()));
}
return userDTOList;
}else{
// 分成两个任务
int mid = empCodeList.size()/2;
MyRecursiveTask leftTeak = new MyRecursiveTask(empCodeList.subList(0, mid));
MyRecursiveTask rightTask = new MyRecursiveTask(empCodeList.subList(mid, empCodeList.size()));
leftTeak.fork();
rightTask.fork();
List<UserDTO> employeeVOList1 = leftTeak.join();
List<UserDTO> employeeVOList2 = rightTask.join();
List<UserDTO> result = new ArrayList<>();
result.addAll(employeeVOList1);
result.addAll(employeeVOList2);
return result;
}
}
}
// 执行ForkJoin查询任务
ForkJoinPool forkJoinPool = new ForkJoinPool();
ForkJoinTask<List<UserDTO>> result = forkJoinPool.submit(new MyRecursiveTask(empCodeList));
List<UserDTO> userDTOList = result.get();
表面上看合情合理，实际上忽视了一个问题，在此之前，配置过feign的拦截器，用来处理feign的请求头信息，传递“Language”标识符用于处理多语言。代码如下：
import javax.servlet.http.HttpServletRequest;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import feign.RequestInterceptor;
import feign.RequestTemplate;
/**
* @author sixiaojie
* @date 2019-12-23 16:31
*/
@Configuration
public class FeignConfiguration implements RequestInterceptor {
@Override
public void apply(RequestTemplate requestTemplate) {
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
if(attributes == null){
return;
}
HttpServletRequest request = attributes.getRequest();
requestTemplate.header("Language", request.getHeader("Language"));
}
}
现在使用多线程异步的方式请求feign接口的时候，RequestContextHolder.getRequestAttributes()获取到的attributes是空的！
然后开始着手处理这个问题。
首先看一下RequestContextHolder的源码
其中
NamedThreadLocal<T> extends ThreadLocal<T>
NamedInheritableThreadLocal<T> extends InheritableThreadLocal<T>
这里就可以看到今天的主角InheritableThreadLocal,再往下看RequestContextHolder提供了一个setRequestAttributes()方法，看下源码：
该方法的注释说，“将给定的请求属性绑定到当前线程。inheritable参数用来设置是否将RequestAttribute公开给子线程继承，即使用InheritableThreadLocal”。那就试试吧，在异步调用feign接口之前，执行一下这个方法：
RequestContextHolder.setRequestAttributes(RequestContextHolder.getRequestAttributes(),true);
将RequestAttribute放到InheritableThreadLocal中。
然后就成功了。
接下来就来聊聊这个InheritableThreadLocal
首先我们知道ThreadLocal解决的是变量在不同线程间的隔离性，也就是不同线程拥有自己的值。类ThreadLocal的主要作用是将数据放入当前线程对象中的Map中,类ThreadLocal自己不管理、不存储任何数据，它只是数据和Map之间的桥梁，Map中的key存储的是ThreadLocal对象，value就是存储的值。每个Thread中的Map值只对当前线程可见，其他线程不可以访问当前线程对象中Map的值。当前线程销毁，Map随之销毁，Map中的数据如果没有被引用、没有被使用，则随时GC收回。由于Map中的key不可以重复，所以一个ThreadLocal对象对应一个value。
类InheritableThreadLocal可以在子线程中取得父线程继承下来的值。JDK的源代码是如何实现这个特性的呢？
这个实现的思路就是在创建子线程时，子线程主动引用父线程中的inheritableThreadLocals对象值，上源码：
Thread中有一个init方法，每次创建线程的时候会执行这个init方法，并且inheriThreadLocals默认传的参数是true，所以当前线程对象每次都会从父线程继承值，子线程将父线程中的table对象以复制的方式赋值给子线程的table数组，这个过程是在创建Thread类对象时发生的，也就说明当子线程对象创建完毕后，子线程中的数据就是主线程中旧的数据，主线程使用新的数据时，子线程还是使用旧的数据，因为主子线程使用两个Entry[]对象数组各自存储自己的值。这个复制其实一个浅拷贝，如果存的值是可变对象的时候，只是复制了对象的引用而已，如果父线程修改对象的属性值，子线程也是可以感知到的。
如果有什么问题，欢迎到公众号后台联系我！
