ThreadLocal是什么

   ThreadLocal是thread local variable(线程局部变量)。线程局部变量(ThreadLocal)其实的功用非常简单,就是为每一个使用该变量的线程都提供一个变量值的副本,是每一个线程都可以独立地改变自己的副本,而不会和其它线程的副本冲突。每个线程只能看到与自己相联系的值,而不知道别的线程可能正在使用或修改它们自己的副本。从线程的角度看,就好像每一个线程都完全拥有该变量。
 ThreadLocal的设计

   首先看看ThreadLocal的接口:

public class ThreadLocal {
            
public Object get();
            
public void set(Object newValue);
            
public Object initialValue();
            }


       Object get() ; // 返回当前线程的线程局部变量副本
           protected Object initialValue(); // 返回该线程局部变量的当前线程的初始值
   void set(Object value); // 设置当前线程的线程局部变量副本的值

   ThreadLocal有3个方法,其中值得注意的是initialValue(),该方法是一个protected的方法,显然是为了子类重写而特意实现的。该方法返回当前线程在该线程局部变量的初始值,这个方法是一个延迟调用方法,在一个线程第1次调用get()或者set(Object)时才执行,并且仅执行1次。ThreadLocal中的确实实现直接返回一个null:

protected Object initialValue() { return null; }

  ThreadLocal是如何做到为每一个线程维护变量的副本的呢?其实实现的思路很简单,在ThreadLocal类中有一个Map,用于存储每一个线程的变量的副本。比如下面的示例实现:
public class ThreadLocal
{
  
private Map values = Collections.synchronizedMap(new HashMap());
  
public Object get()
  
{
   Thread curThread 
= Thread.currentThread(); 
   Object o 
= values.get(curThread); 
   
if (o == null && !values.containsKey(curThread))
   
{
    o 
= initialValue();
    values.put(curThread, o); 
   }

   
return o; 
  }


  
public void set(Object newValue)
  
{
   values.put(Thread.currentThread(), newValue);
  }


  
public Object initialValue()
  
{
   
return null
  }

}

这个实现的性能不会很好,因为每个 get()set() 操作都需要 values 映射表上的同步,而且如果多个线程同时访问同一个 ThreadLocal ,那么将发生争用。此外,这个实现也是不切实际的,因为用 Thread 对象做 values 映射表中的关键字将导致无法在线程退出后对 Thread 进行垃圾回收,而且也无法对死线程的 ThreadLocal 的特定于线程的值进行垃圾回收。




但JDK中的ThreadLocal的实现总体思路也类似于此。




  j2EE中的Thread

         Web容器中有三个周期request/Httpsession/application
         其中request是客户端发出的一个请求,这个request的载体就是一个线程,实际等同于一个线程的生命周期。Request是封装在线程上面一个抽象概念。而ThreadLocal则相当于多个线程的一个共享全局变量存储地,它里面保存的是和每个线程相关的状态。所以threadLocal是为线程服务的,和线程处于一个底层位置。

         正因为Spring/Hibernate这些框架对于状态处理短处,所以才只能透过Web容器的request等状态封装,直接到底层操作与线程同一层次的threadLocal。

         当一个线程或request结束时,threadlocal中的状态就没有了,所以threadLocal基本类似request.setAttribute作用,threadLocal中的对象状态的生命周期等同于request.


 ThreadLocal的使用



用 ThreadLocal 实现每线程 Singleton

线程局部变量常被用来描绘有状态“单子”(Singleton) 或线程安全的共享对象,或者是通过把不安全的整个变量封装进 ThreadLocal ,或者是通过把对象的特定于线程的状态封装进 ThreadLocal 。例如,在与数据库有紧密联系的应用程序中,程序的很多方法可能都需要访问数据库。在系统的每个方法中都包含一个 Connection 作为参数是不方便的 — 用“单子”来访问连接可能是一个虽然更粗糙,但却方便得多的技术。然而,多个线程不能安全地共享一个 JDBC Connection 。如清单 3 所示,通过使用“单子”中的 ThreadLocal ,我们就能让我们的程序中的任何类容易地获取每线程 Connection 的一个引用。这样,我们可以认为 ThreadLocal 允许我们创建 每线程单子


清单 3. 把一个 JDBC 连接存储到一个每线程 Singleton 中

 

 public class ConnectionDispenser {
            
private static class ThreadLocalConnection extends ThreadLocal {
            
public Object initialValue() {
            
return DriverManager.getConnection(ConfigurationSingleton.getDbUrl());
            }

            }

            
private ThreadLocalConnection conn = new ThreadLocalConnection();
            
public static Connection getConnection() {
            
return (Connection) conn.get();
            }

            }

            


任何创建的花费比使用的花费相对昂贵些的有状态或非线程安全的对象,例如 JDBC Connection 或正则表达式匹配器,都是可以使用每线程单子(singleton)技术的好地方。当然,在类似这样的地方,您可以使用其它技术,例如用池,来安全地管理共享访问。然而,从可伸缩性角度看,即使是用池也存在一些潜在缺陷。因为池实现必须使用同步,以维护池数据结构的完整性,如果所有线程使用同一个池,那么在有很多线程频繁地对池进行访问的系统中,程序性能将因争用而降低。
 


用 ThreadLocal 简化调试日志纪录

其它适合使用 ThreadLocal 但用池却不能成为很好的替代技术的应用程序包括存储或累积每线程上下文信息以备稍后检索之用这样的应用程序。例如,假设您想创建一个用于管理多线程应用程序调试信息的工具。您可以用如清单 4 所示的 DebugLogger 类作为线程局部容器来累积调试信息。在一个工作单元的开头,您清空容器,而当一个错误出现时,您查询该容器以检索这个工作单元迄今为止生成的所有调试信息。


清单 4. 用 ThreadLocal 管理每线程调试日志

 

   public class DebugLogger {
            
private static class ThreadLocalList extends ThreadLocal {
            
public Object initialValue() {
            
return new ArrayList();
            }

            
public List getList() {
            
return (List) super.get();
            }

            }

            
private ThreadLocalList list = new ThreadLocalList();
            
private static String[] stringArray = new String[0];
            
public void clear() {
            list.getList().clear();
            }

            
public void put(String text) {
            list.getList().add(text);
            }

            
public String[] get() {
            
return list.getList().toArray(stringArray);
            }

            }

            


在您的代码中,您可以调用 DebugLogger.put() 来保存您的程序正在做什么的信息,而且,稍后如果有必要(例如发生了一个错误),您能够容易地检索与某个特定线程相关的调试信息。 与简单地把所有信息转储到一个日志文件,然后努力找出哪个日志记录来自哪个线程(还要担心线程争用日志纪录对象)相比,这种技术简便得多,也有效得多。

ThreadLocal 在基于 servlet 的应用程序或工作单元是一个整体请求的任何多线程应用程序服务器中也是很有用的,因为在处理请求的整个过程中将要用到单个线程。您可以通过前面讲述的每线程单子技术用 ThreadLocal 变量来存储各种每请求(per-request)上下文信息。






   如果希望线程局部变量初始化其它值,那么需要自己实现ThreadLocal的子类并重写该方法,通常使用一个内部匿名类对ThreadLocal进行子类化,比如下面的例子,SerialNum类为每一个类分配一个序号:

public class SerialNum
{
  // The next serial number to be assigned

  private static int nextSerialNum = 0;
  private static ThreadLocal serialNum = new ThreadLocal()
  {
   protected synchronized Object initialValue()
   {
    return new Integer(nextSerialNum++);
   }
  };

  public static int get()
  {
   return ((Integer) (serialNum.get())).intValue();
  }
}

  SerialNum类的使用将非常地简单,因为get()方法是static的,所以在需要获取当前线程的序号时,简单地调用:

int serial = SerialNum.get();

  即可。

   在线程是活动的并且ThreadLocal对象是可访问的时,该线程就持有一个到该线程局部变量副本的隐含引用,当该线程运行结束后,该线程拥有的所以线程局部变量的副本都将失效,并等待垃圾收集器收集。

   ThreadLocal与其它同步机制的比较

   ThreadLocal和其它同步机制相比有什么优势呢?ThreadLocal和其它所有的同步机制都是为了解决多线程中的对同一变量的访问冲突,在普通的同步机制中,是通过对象加锁来实现多个线程对同一变量的安全访问的。这时该变量是多个线程共享的,使用这种同步机制需要很细致地分析在什么时候对变量进行读写,什么时候需要锁定某个对象,什么时候释放该对象的锁等等很多。所有这些都是因为多个线程共享了资源造成的。ThreadLocal就从另一个角度来解决多线程的并发访问,ThreadLocal会为每一个线程维护一个和该线程绑定的变量的副本,从而隔离了多个线程的数据,每一个线程都拥有自己的变量副本,从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象,在编写多线程代码时,可以把不安全的整个变量封装进ThreadLocal,或者把该对象的特定于线程的状态封装进ThreadLocal。

   由于ThreadLocal中可以持有任何类型的对象,所以使用ThreadLocal get当前线程的值是需要进行强制类型转换。但随着新的Java版本(1.5)将模版的引入,新的支持模版参数的ThreadLocal<T>类将从中受益。也可以减少强制类型转换,并将一些错误检查提前到了编译期,将一定程度地简化ThreadLocal的使用。

   总结

   当然ThreadLocal并不能替代同步机制,两者面向的问题领域不同。同步机制是为了同步多个线程对相同资源的并发访问,是为了多个线程之间进行通信的有效方式;而ThreadLocal是隔离多个线程的数据共享,从根本上就不在多个线程之间共享资源(变量),这样当然不需要对多个线程进行同步了。所以,如果你需要进行多个线程之间进行通信,则使用同步机制;如果需要隔离多个线程之间的共享冲突,可以使用ThreadLocal,这将极大地简化你的程序,使程序更加易读、简洁。


实例:
public class Hello implements Runnable{
    
static class Counter{
        
int c = 0;
        
public void Count(){
            System.
out.println(Thread.currentThread().hashCode() + ""+ c++);
        }

    }

    
private static ThreadLocal counter = new ThreadLocal(){
        
protected Object initialValue() {return new Counter();}
    }
;
    
public static Counter Counter(){return (Counter)counter.get();} 
    
    
public static void main(String[] args)throws Exception {
        Hello h 
= new Hello();
        h.run();
        
new Thread(new Hello()).start();
        Thread.sleep(
1000L);
        h.run();
        Counter().Count();
    }


    
public void run() {
        Counter().Count();
        Counter().Count();
        Counter().Count();
    }

}


结果:
253585550
253585551
253585552
263995540
263995541
263995542
253585553
253585554
253585555
253585556

看样ThreadLocal工作的很好.请注意ThreadLocal类似一个访问媒介,get()返回的值是存储在当前线程中的.

值得注意的是InheritableThreadLocal类,可以使ThreadLocal数据传递到子线程中.

另外servlet线程可能会被重新利用,要注意在每个servlet开始时重新初始化.