threadlocal原理及常用应用场景2

最近项目中遇到如下的场景：在执行数据迁移时，需要按照用户粒度加锁，因此考虑使用排他锁，迁移工具和业务服务属于两个服务，因此需要使用分布式锁。

我们使用缓存（Tair或者Redis）实现分布式锁，具体代码如下：

1. @Service  
2. public class Locker {  
3.     @Resource(name = "tairClientUtil")  
4.     private TairClientUtil tairClientUtil;  
5.   
6.     private ThreadLocal lockerBeanThreadLocal = new ThreadLocal<>();  
7.   
8.     public void init(long userid) {  
9.         lockerBeanThreadLocal.remove();  
10.         lockerBeanThreadLocal.set(userid);  
11.     }  
12.   
13.     public void updateLock() {  
14.         String lockKey = Constants.MIGRATION_PREFIX + lockerBeanThreadLocal.get();  
15.         tairClientUtil.incr(lockKey, Constants.COUNT_EXPIRE);  
16.     }  
17.   
18.     public void invalidLock() {  
19.         String lockKey = Constants.MIGRATION_PREFIX + lockerBeanThreadLocal.get();  
20.         tairClientUtil.invalid(lockKey);  
21.     }  
22. }  
23.   
24. 作者：杜琪  
25. 链接：http://www.jianshu.com/p/cadd53f063b9  

因为每个线程可能携带不同的userid发起请求，因此在这里使用ThreadLocal变量存放userid，使得每个线程都有一份自己的副本。

参考官方文档：ThreadLocal的用法，这个类提供“thread-local”变量，这些变量与线程的局部变量不同，每个线程都保存一份改变量的副本，可以通过get或者set方法访问。如果开发者希望将类的某个静态变量（user ID或者transaction ID）与线程状态关联，则可以考虑使用ThreadLocal。

举个例子，下面的类为每个线程生成不同的ID，当某个线程第一次调用Thread.get()时，会为该线程赋予一个ID，并且在后续的调用中不再改变。

 

1. import java.util.concurrent.atomic.AtomicInteger;  
2.   
3.  public class ThreadId {  
4.      // Atomic integer containing the next thread ID to be assigned  
5.      private static final AtomicInteger nextId = new AtomicInteger(0);  
6.   
7.      // Thread local variable containing each thread's ID  
8.      private static final ThreadLocal threadId =  
9.          new ThreadLocal() {  
10.              @Override protected Integer initialValue() {  
11.                  return nextId.getAndIncrement();  
12.          }  
13.      };  
14.   
15.      // Returns the current thread's unique ID, assigning it if necessary  
16.      public static int get() {  
17.          return threadId.get();  
18.      }  
19.  }  
20.   
21.  
22.   每个线程会“隐式”包含一份thread-local变量的副本，只要线程还处于活跃状态，就可以访问该变量；当线程停止后，如果没有其他线程持有该thread-local变量，则该变量的副本会提交给垃圾回收器。 
24.  
25. /** 
26.  * {@link ThreadLocal} subclass that exposes a specified name 
27.  * as {@link #toString()} result (allowing for introspection). 
28.  * 
29.  * @author Juergen Hoeller 
30.  * @since 2.5.2 
31.  * @see NamedInheritableThreadLocal 
32.  */  
33. public class NamedThreadLocal extends ThreadLocal {  
34.   
35.     private final String name;  
36.   
37.   
38.     /** 
39.      * Create a new NamedThreadLocal with the given name. 
40.      * @param name a descriptive name for this ThreadLocal 
41.      */  
42.     public NamedThreadLocal(String name) {  
43.         Assert.hasText(name, "Name must not be empty");  
44.         this.name = name;  
45.     }  
46.   
47.     @Override  
48.     public String toString() {  
49.         return this.name;  
50.     }  
51.   
52. }  
54.  
55. XmlBeanDefinitionReader.java  
56.   
57. private final ThreadLocal> resourcesCurrentlyBeingLoaded =  
58.             new NamedThreadLocal>("XML bean definition resources currently being loaded");  
59.   
60.     /** 
61.      * Load bean definitions from the specified XML file. 
62.      * @param encodedResource the resource descriptor for the XML file, 
63.      * allowing to specify an encoding to use for parsing the file 
64.      * @return the number of bean definitions found 
65.      * @throws BeanDefinitionStoreException in case of loading or parsing errors 
66.      */  
67.     public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {  
68.         Assert.notNull(encodedResource, "EncodedResource must not be null");  
69.         if (logger.isInfoEnabled()) {  
70.             logger.info("Loading XML bean definitions from " + encodedResource.getResource());  
71.         }  
72.   
73.         Set currentResources = this.resourcesCurrentlyBeingLoaded.get();  
74.         if (currentResources == null) {  
75.             currentResources = new HashSet(4);  
76.             this.resourcesCurrentlyBeingLoaded.set(currentResources);  
77.         }  
78.         if (!currentResources.add(encodedResource)) {  
79.             throw new BeanDefinitionStoreException(  
80.                     "Detected cyclic loading of " + encodedResource + " - check your import definitions!");  
81.         }  
82.         try {  
83.             InputStream inputStream = encodedResource.getResource().getInputStream();  
84.             try {  
85.                 InputSource inputSource = new InputSource(inputStream);  
86.                 if (encodedResource.getEncoding() != null) {  
87.                     inputSource.setEncoding(encodedResource.getEncoding());  
88.                 }  
89.                 return doLoadBeanDefinitions(inputSource, encodedResource.getResource());  
90.             }  
91.             finally {  
92.                 inputStream.close();  
93.             }  
94.         }  
95.         catch (IOException ex) {  
96.             throw new BeanDefinitionStoreException(  
97.                     "IOException parsing XML document from " + encodedResource.getResource(), ex);  
98.         }  
99.         finally {  
100.             currentResources.remove(encodedResource);  
101.             if (currentResources.isEmpty()) {  
102.                 this.resourcesCurrentlyBeingLoaded.remove();  
103.             }  
104.         }  
105.     }