(5)ThreadLocal类及应用技巧---- 线程范围内共享变量

java.lang 
类 ThreadLocal<T>


java.lang.Object
  java.lang.ThreadLocal<T>
直接已知子类: 
InheritableThreadLocal 


public class ThreadLocal<T>extends Object该类提供了线程局部 (thread-local) 变量。


这些变量不同于它们的普通对应物,因为访问某个变量(通过其 get 或 set 方法)的每个线程都有自己的局部变量,它独立于变量的初始化副本。


ThreadLocal 实例通常是类中的 private static 字段,

它们希望将状态与某一个线程(例如,用户 ID 或事务 ID)相关联。 


例如,以下类生成对每个线程唯一的局部标识符。线程 ID 是在第一次调用 UniqueThreadIdGenerator.getCurrentThreadId() 时分配的,在后续调用中不会更改。
 


  
[java]  view plain copy print ?
  1. import java.util.concurrent.atomic.AtomicInteger;  
  2.   
  3.   
  4.  public class UniqueThreadIdGenerator {  
  5.   
  6.   
  7.      private static final AtomicInteger uniqueId = new AtomicInteger(0);  
  8.   
  9.   
  10.      private static final ThreadLocal < Integer > uniqueNum =   
  11.          new ThreadLocal < Integer > () {  
  12.              @Override protected Integer initialValue() {  
  13.                  return uniqueId.getAndIncrement();  
  14.          }  
  15.      };  
  16.    
  17.      public static int getCurrentThreadId() {  
  18.          return uniqueId.get();  
  19.      }  
  20.  } // UniqueThreadIdGenerator  


 每个线程都保持对其线程局部变量副本的隐式引用,只要线程是活动的并且 ThreadLocal 实例是可访问的;

在线程消失之后,其线程局部实例的所有副本都会被垃圾回收(除非存在对这些副本的其他引用)。
 


ThreadfLocal


         ThreadfLocal是一种机制,很多人都说它的名字叫ThreadfLocalVariable更贴切。表面上看它和其他的java类没有区别,但是当一个多线程系统要求各个线程都有自己线程内的全局变量时,使用ThreadfLocal就是一个极佳的选择。

        ThreadfLocal用于实现线程内的数据共享,即对于相同的程序代码,多个模块在同一个线程中运行时要共享一份数据,而在另外线程中运行时又共享另外一份数据。举个例子,我们在学校食堂排队打饭,对于甲同学打饭的全过程(线程一),那几个打饭、打菜和打汤的模块操作的(饭盆)变量是甲同学拿的饭盆;对于乙同学打饭的全过程(线程二),那几个打饭、打菜和打汤的模块操作的(饭盆)变量是乙同学拿的饭盆;在这个例子里,饭盆就可以视为应当存放到ThreadLocal里的共享变量。

 

         可能有人提到全局共享变量会想到用static变量,但是static变量的全局范围比ThreadfLocal里的更“全局”--在整个运行的jvm里只有一份,即虽然static变量可以被多个模块共享,但同时也是在多线程范围内共享。所以,用static是不能满足我们的业务需求的。当然,ThreadfLocal变量为static没有问题。

 

              ThreadLocal的一个常用业务场景是:在订单处理业务流中,减少库存量、增加一条流水台账、修改总账,这几个操作要在同一个事务中完成,通常也即同一个线程中进行处理,如果累加公司应收款的操作失败了,则应该把前面的操作回滚,否则,提交所有操作,这要求这些操作使用相同的数据库连接对象,而这些操作的代码分别位于不同的模块类中。

 

Thread与同步机制的比较


ThreadLocal和同步机制都是为了解决多线程中对相同变量的访问冲突的问题。

 

同步机制是通过锁对象机制保证同一时间只有一个线程访问变量。这时该变量是多个线程共享的,使用同步机制要求程序慎密地分析什么时候对变量进行读写,什么时候需要锁定某个对象,什么时候释放对象锁等繁杂的问题,程序设计和编写难度相对较大。

 

而ThreadLocal则从另一个角度来解决多线程的并发访问。ThreadLocal会为每一个线程提供一个独立的变量副本,从而隔离了多个线程对数据的访问冲突。因为每一个线程都拥有自己的变量副本,从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象,在编写多线程代码时,可以把不安全的变量封装进ThreadLocal。

 

概括起来说,对于多线程资源共享的问题,同步机制采用了“以时间换空间”的方式,而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量,让不同的线程排队访问,而后者为每一个线程都提供了一份变量,因此可以同时访问而互不影响。

 

不过,ThreadLocal并不能替代同步机制,两者面向的问题领域不同:ThreadLocal考虑的是变量在线程间的隔离;同步机制则提供了线程间通信的桥梁。




[java]  view plain copy print ?
  1. package com.itm.thread;  
  2.   
  3. import java.util.Random;  
  4. /************ 
  5.  *  
  6.  * 利用 ThreadLocal 。 
  7.  *  
  8.  * @author  
  9.  * 
  10.  */  
  11. public class ThreadLocalTest {  
  12.   
  13.     private static ThreadLocal<Integer> x = new ThreadLocal<Integer>();// 泛型。  
  14.       
  15.       
  16. //  private static ThreadLocal<MyThreadScopeData> myThreadScopeData = new ThreadLocal<MyThreadScopeData>();  
  17.           
  18.     public static void main(String[] args) {  
  19.         for(int i=0;i<2;i++){ // 用来创建两个线程。  
  20.             new Thread( new Runnable(){ // 创建好一个线程。  
  21.                 @Override  
  22.                 public void run() {  
  23.                     int data = new Random().nextInt(); // 准备好数据。  
  24.                     System.out.println(Thread.currentThread().getName() +   
  25.                             "  has put data :" + data);  
  26.                       
  27.                     x.set(data);// 向当前线程里面放入一个数据。把数据 存在当前线程里面去了。。。  
  28.                       
  29.                       
  30.                     /*********** 
  31.                      *  
  32.                      * 多个变量。 
  33.                      *  
  34.                      * 存数据。 
  35.                      *  
  36.                      */  
  37.                     /*MyThreadScopeData myData =  new MyThreadScopeData(); // new 一个这样的对象。 
  38.                     myData.setName("name " + data); 
  39.                     myData.setAge(data); 
  40.                     myThreadScopeData.set(myData); // 存数据。。。 
  41. */                    
  42.                     new A().get(); // A 去取数据。  
  43.                     new B().get();  
  44.                 }  
  45.             }).start();  
  46.         }  
  47.     }  
  48.       
  49.     static class A{  
  50.         public void get(){  
  51.             int data = x.get();// 取出  存入当前线程里面的数据。。。  
  52.             System.out.println("A form " + Thread.currentThread().getName() + "  get data :" + data);  
  53.               
  54.               
  55.             /*MyThreadScopeData myData = myThreadScopeData.get(); 
  56.             System.out.println("A form " + Thread.currentThread().getName() +  
  57.                     " getMyData : " +  
  58.                         myData.getName() + "," + myData.getAge()); 
  59.             */  
  60.               
  61.         }  
  62.     }  
  63.       
  64.     static class B{  
  65.         public void get(){  
  66.             int data = x.get();  
  67.             System.out.println("B form " + Thread.currentThread().getName() + "  get data :" + data);  
  68.         }  
  69.     }  
  70.   
  71. }  
  72.   
  73. /*class MyThreadScopeData { 
  74.     private String name; 
  75.     private int age; 
  76.     public String getName() { 
  77.         return name; 
  78.     } 
  79.     public void setName(String name) { 
  80.         this.name = name; 
  81.     } 
  82.     public int getAge() { 
  83.         return age; 
  84.     } 
  85.     public void setAge(int age) { 
  86.         this.age = age; 
  87.     } 
  88. }*/  
结果:

Thread-0  has put data :1365978062
A form Thread-0  get data :1365978062
Thread-1  has put data :-770297261
A form Thread-1  get data :-770297261
B form Thread-1  get data :-770297261
B form Thread-0  get data :1365978062

如果 线程范围内 有  N个变量  那应该怎么办呢??一个 threadLocal代表一个变量,

故其中里只能放一个数据。你有两个变量都要线程范围内共享,则要定义两个threadLocal对象,

如果有一百个变量要线程共享呢?那请先定义一个对象来装这一百个变量,然后在threadLocal中存储这个对象。


[java]  view plain copy print ?
  1. package com.itm.thread;  
  2.   
  3. import java.util.Random;  
  4. /************ 
  5.  *  
  6.  * 利用 ThreadLocal 。 
  7.  *  
  8.  * @author  
  9.  * 
  10.  */  
  11. public class ThreadLocalTest {  
  12.   
  13.     private static ThreadLocal<Integer> x = new ThreadLocal<Integer>();// 泛型。  
  14.       
  15.       
  16.     private static ThreadLocal<MyThreadScopeData> myThreadScopeData = new ThreadLocal<MyThreadScopeData>();  
  17.           
  18.     public static void main(String[] args) {  
  19.         for(int i=0;i<2;i++){ // 用来创建两个线程。  
  20.             new Thread( new Runnable(){ // 创建好一个线程。  
  21.                 @Override  
  22.                 public void run() {  
  23.                     int data = new Random().nextInt(); // 准备好数据。  
  24.                     System.out.println(Thread.currentThread().getName() +   
  25.                             "  has put data :" + data);  
  26.                       
  27.                     x.set(data);// 向当前线程里面放入一个数据。把数据 存在当前线程里面去了。。。  
  28.                       
  29.                       
  30.                     /*********** 
  31.                      *  
  32.                      * 多个变量。 
  33.                      *  
  34.                      * 存数据。 
  35.                      *  
  36.                      */  
  37.                     MyThreadScopeData myData =  new MyThreadScopeData(); // new 一个这样的对象。  
  38.                     myData.setName("name " + data);  
  39.                     myData.setAge(data);  
  40.                     myThreadScopeData.set(myData); // 存数据。。。  
  41.                       
  42.                     new A().get(); // A 去取数据。  
  43.                     new B().get();  
  44.                 }  
  45.             }).start();  
  46.         }  
  47.     }  
  48.       
  49.     static class A{  
  50.         public void get(){  
  51.             int data = x.get();// 取出  存入当前线程里面的数据。。。  
  52.             System.out.println("A form " + Thread.currentThread().getName() + "  get data :" + data);  
  53.               
  54.               
  55.             MyThreadScopeData myData = myThreadScopeData.get();  
  56.             System.out.println("A form " + Thread.currentThread().getName() +   
  57.                     " getMyData : " +   
  58.                         myData.getName() + "," + myData.getAge());  
  59.               
  60.               
  61.         }  
  62.     }  
  63.       
  64.     static class B{  
  65.         public void get(){  
  66.             int data = x.get();  
  67.             System.out.println("B form " + Thread.currentThread().getName() + "  get data :" + data);  
  68.         }  
  69.     }  
  70.   
  71. }  
  72.   
  73. class MyThreadScopeData {  
  74.     private String name;  
  75.     private int age;  
  76.     public String getName() {  
  77.         return name;  
  78.     }  
  79.     public void setName(String name) {  
  80.         this.name = name;  
  81.     }  
  82.     public int getAge() {  
  83.         return age;  
  84.     }  
  85.     public void setAge(int age) {  
  86.         this.age = age;  
  87.     }  
  88. }  

Thread-0  has put data :-485439611
Thread-1  has put data :198643933
A form Thread-0  get data :-485439611
A form Thread-0 getMyData : name -485439611,-485439611
A form Thread-1  get data :198643933
A form Thread-1 getMyData : name 198643933,198643933
B form Thread-1  get data :198643933
B form Thread-0  get data :-485439611



一中 更加优雅的写法:


[java]  view plain copy print ?
  1. package com.itm.thread;  
  2.   
  3. import java.util.Random;  
  4. /************ 
  5.  *  
  6.  * 利用 ThreadLocal 。自己线程范围内的对象。 
  7.  *  
  8.  * @author  
  9.  * 
  10.  */  
  11. public class CopyOfThreadLocalTest2 {  
  12.   
  13.     private static ThreadLocal<Integer> x = new ThreadLocal<Integer>();  
  14.       
  15.     private static ThreadLocal<MyThreadScopeDataTwo> myThreadScopeDataTwo = new ThreadLocal<MyThreadScopeDataTwo>();  
  16.           
  17.     public static void main(String[] args) {  
  18.         for(int i=0;i<2;i++){ // 用来创建两个线程。  
  19.             new Thread( new Runnable(){ // 创建好一个线程。  
  20.                 @Override  
  21.                 public void run() {  
  22.                     int data = new Random().nextInt(); // 准备好数据。  
  23.                     System.out.println(Thread.currentThread().getName() +   
  24.                             "  has put data :" + data);  
  25.                       
  26.                     x.set(data);// 向当前线程里面放入一个数据。  
  27.                       
  28.                       
  29.                       
  30.                     /*MyThreadScopeDataTwo myData =  new MyThreadScopeDataTwo(); 
  31.                     myData.setName("name " + data); 
  32.                     myData.setAge(data); 
  33.                     myThreadScopeDataTwo.set(myData);*/  
  34.                       
  35.                     // MyThreadScopeDataTwo.getThreadInstance() 拿到与 本线程相关的实例。  
  36.                     MyThreadScopeDataTwo.getThreadInstance().setName("name " + data);  
  37.                     MyThreadScopeDataTwo.getThreadInstance().setAge(data);  
  38.                       
  39.                     new A().get(); // A 去取数据。  
  40.                     new B().get();  
  41.                 }  
  42.             }).start();  
  43.         }  
  44.     }  
  45.       
  46.     static class A{  
  47.         public void get(){  
  48.             int data = x.get();  
  49.             System.out.println("A form " + Thread.currentThread().getName() + "  get data :" + data);  
  50.               
  51.             MyThreadScopeDataTwo myData = MyThreadScopeDataTwo.getThreadInstance();  
  52.               
  53.             System.out.println("A form " + Thread.currentThread().getName() +   
  54.                     " getMyData : " +   
  55.                         myData.getName() + "," + myData.getAge());  
  56.               
  57.               
  58.         }  
  59.     }  
  60.       
  61.     static class B{  
  62.         public void get(){  
  63.             int data = x.get();  
  64.             System.out.println("B form " + Thread.currentThread().getName() + "  get data :" + data);  
  65.               
  66.             MyThreadScopeDataTwo myData = MyThreadScopeDataTwo.getThreadInstance();  
  67.               
  68.             System.out.println("A form " + Thread.currentThread().getName() +   
  69.                     " getMyData : " +   
  70.                         myData.getName() + "," + myData.getAge());  
  71.         }  
  72.     }  
  73.   
  74. }  
  75.   
  76. class MyThreadScopeDataTwo {  
  77.       
  78.     /* 
  79.      *  
  80.        
  81.           饱汉式。:人家还没有调用我  我就把这个对象创建出来了。 
  82.             private  MyThreadScopeDataTwo(){} 
  83.             public static MyThreadScopeDataTwo getInstance(){ 
  84.                 return instance; 
  85.             } 
  86.             private static MyThreadScopeDataTwo instance = new MyThreadScopeDataTwo(); 
  87.          
  88.          
  89.     */  
  90.       
  91.     /* 
  92.       
  93.             饿汉式: 
  94.             private  MyThreadScopeDataTwo(){} 
  95.             // 加上 synchronized 时,这个对象就只能创建一个了。 
  96.             public static synchronized MyThreadScopeDataTwo getInstance(){ 
  97.                 if(instance == null){ 
  98.                     instance = new MyThreadScopeDataTwo(); 
  99.                 } 
  100.                 return instance; 
  101.             } 
  102.             private static MyThreadScopeDataTwo instance = null; 
  103.      
  104.     */  
  105.       
  106.       
  107.     private  MyThreadScopeDataTwo(){}  
  108.     public static /*synchronized*/ MyThreadScopeDataTwo getThreadInstance(){  
  109.         MyThreadScopeDataTwo instance = map.get();  
  110.         if(instance == null){ // 不用加上  synchronized,两个线程各是各的实例。  
  111.             instance = new MyThreadScopeDataTwo();  
  112.             map.set(instance); // 把对象 放进去。。  
  113.         }  
  114.         return instance;  
  115.     }  
  116.       
  117.     // 用来专门装对象的。。。  
  118.     private static ThreadLocal<MyThreadScopeDataTwo> map = new ThreadLocal<MyThreadScopeDataTwo>();  
  119.       
  120.     private String name;  
  121.     private int age;  
  122.     public String getName() {  
  123.         return name;  
  124.     }  
  125.     public void setName(String name) {  
  126.         this.name = name;  
  127.     }  
  128.     public int getAge() {  
  129.         return age;  
  130.     }  
  131.     public void setAge(int age) {  
  132.         this.age = age;  
  133.     }  
  134. }  

更多  threadLocal 借鉴:

http://blog.csdn.net/qjyong/article/details/2158097

http://www.iteye.com/topic/103804

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值