多线程（八）~ThreadLocal、InheritableThreadLocal的使用

通过前面的学习，我们了解了在多线程+成员变量等情况下会出现线程安全的问题。那么解决线程安全问题除了使用synchronize关键字之外，还有另一种常用的解决思路，那就是使用ThreadLocal类，下面我们会对这个类做一下简介并指出两者的差异。

 

    ThreadLocal：通过字面翻译过来意思是“线程本地”，代表线程自己的本地变量。在多线程环境下，所有线程会共享类中的成员变量，那么这种情况下有可能会引发线程安全的问题。如果线程有自己的本地变量是不是就不会冲突了，ThreadLocal的原理就是这样，为线程创建自己的本地变量，多个线程间不共享。

 

    线程本地变量最初始是空值null，最最常用的方法就是get()、set(Object value)，其实这些值是维护在一个ThreadLocalMap中的。

  简单的get()、set()的demo：

1. package com.multiThread.test.mythreadlocal;
3. publicclassSampleTest{
5. //线程本地变量
6. publicstaticThreadLocal tl =newThreadLocal();
8. publicstaticvoid main(String[] args){
9. if(tl.get()==null){
10. System.out.println("线程初始变量是空值");
11. tl.set("我的值");
12. }
13. System.out.println(tl.get());
14. System.out.println(tl.get());
15. }
16. }

 

线程变量的隔离性（非共享）

线程本地变量工具类：

1. package com.multiThread.util;
3. publicclassThreadLocalUtil{
4. publicstaticfinalThreadLocal<String> tl =newThreadLocal<String>();
5. }

线程类：

1. package com.multiThread.thread;
3. import com.multiThread.util.ThreadLocalUtil;
5. publicclassMyThreadLocalAimplementsRunnable{
6. @Override
7. publicvoid run(){
8. for(int i =0;i<100;i++){
9. ThreadLocalUtil.tl.set("ThreadA:"+(i +1));
10. System.out.println("ThreadA:"+ThreadLocalUtil.tl.get());
11. try{
12. Thread.sleep(20);
13. }catch(InterruptedException e){
14. e.printStackTrace();
15. }
16. }
17. }
18. }

1. package com.multiThread.thread;
3. import com.multiThread.util.ThreadLocalUtil;
5. publicclassMyThreadLocalBimplementsRunnable{
6. @Override
7. publicvoid run(){
8. for(int i =0;i<100;i++){
9. ThreadLocalUtil.tl.set("ThreadB:"+(i +1));
10. System.out.println("ThreadB:"+ThreadLocalUtil.tl.get());
11. try{
12. Thread.sleep(20);
13. }catch(InterruptedException e){
14. e.printStackTrace();
15. }
16. }
17. }
18. }

测试类：

1. package com.multiThread.test.mythreadlocal;
3. import com.multiThread.thread.MyThreadLocalA;
4. import com.multiThread.thread.MyThreadLocalB;
6. publicclassMyThreadRun{
7. publicstaticvoid main(String[] args){
8. MyThreadLocalA myThreadLocalA =newMyThreadLocalA();
9. MyThreadLocalB myThreadLocalB =newMyThreadLocalB();
11. Thread t1 =newThread(myThreadLocalA);
12. Thread t2 =newThread(myThreadLocalB);
14. t1.start();
15. t2.start();
16. }
17. }

测试结果：

1. .
2. .
3. .
4. ThreadB:ThreadB:95
5. ThreadA:ThreadA:95
6. ThreadB:ThreadB:96
7. ThreadA:ThreadA:96
8. ThreadB:ThreadB:97
9. ThreadA:ThreadA:97
10. ThreadA:ThreadA:98
11. ThreadB:ThreadB:98
12. ThreadB:ThreadB:99
13. ThreadA:ThreadA:99
14. ThreadB:ThreadB:100
15. ThreadA:ThreadA:100

通过结果可以看出线程A和线程B之间的变量并非共享的，线程本地变量具有隔离性，只是自己用的。

 

为线程本地变量初始化值：

    继承自ThreadLocal类，并实现initialValue()，设置返回值即可。

1. publicstaticfinalThreadLocal myLocal =newThreadLocal(){
2. protectedObject initialValue(){
3. return250;
4. };
5. };

1. System.out.println("默认值为：" + TicketThread.myLocal.get());

1. 默认值为：250

 

InheritableThreadLocal可以使子线程能从父线程中获取本地变量的值，例如：

子线程类：

1. package com.wang.threadlocal;
3. publicclassPersonimplementsRunnable{
4. @Override
5. publicvoid run(){
6. System.out.println("从父线程中获取线程变量："+MyInheritableThradLocal.threadLocal.get());
7. }
8. }

 

测试类：

1. package com.wang.threadlocal;
3. publicclassInheritableTest{
4. publicstaticvoid main(String[] args){
5. MyInheritableThradLocal.threadLocal.set("who let the dogs out?");
6. System.out.println("Main线程中的值为："+MyInheritableThradLocal.threadLocal.get());
7. Person person =newPerson();
8. Thread t1 =newThread(person);
9. t1.start();
10. }
11. }

从例子中可以看出，在main线程中设置的线程本地变量，在子线程中也能拿到。

注意：若子线程获取值的同时，父线程对线程本地变量值做了修改，则子线程取到的值还是原值。

 

 

 

    

来自为知笔记(Wiz)