java基础 ThreadLocal

今天学习了ThreadLocal，和大家分享下，理解的不是很透彻。

API中的解释是：

该类提供了线程局部 变量。这些变量不同于它们的普通对应物，因为访问某个变量（通过其 get 或 set 方法）的每个线程都有自己的局部变量，它独立于变量的初始化副本。ThreadLocal 实例通常是类中的 private static 字段，它们希望将状态与某一个线程（例如，用户 ID 或事务 ID）相关联。

网上一些说是（1）为了解决多线程并发的问题，我没有看出来；

另有一些说法是（2）ThreadLocal和多线程并发没有什么关系。ThreadLocal模式是为了解决单线程内的跨类跨方法调用的，有点AOP的味道；

此处待慢慢学习，不做评论。

 

实现原理，这边写了一个简单的SmipleThreadLocal的例子，代码粗糙，但是和ThreadLocal的设计思路是一样的

 

 

 

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

/**
 * @author Eva

 * threadLocal 的雏形
 */
public class SimpleThreadLocal {
 private Map valueMap = Collections.synchronizedMap(new HashMap());

 public void set(Object newValue) {
  valueMap.put(Thread.currentThread(), newValue);// 键为线程对象，值为本线程的变量副本
 }

 public Object get() {
  Thread thread = Thread.currentThread();
  Object o = valueMap.get(thread);// 本线程对应的变量
  if (o == null && !valueMap.containsKey(thread)) {
   o = initialValue();// 如果map中不存在，则初始化并且放在Map中
   valueMap.put(thread, o);
  }
  return o;

 }

 public Object initialValue() {
  return null;
 }

 public void remove() {
  valueMap.remove(Thread.currentThread());
 }
}

 

 

ThreadLocal的接口方法：

• void set(Object value)

设置当前线程的线程局部变量的值。

• public Object get()

该方法返回当前线程所对应的线程局部变量。

• public void remove()

将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。

• protected Object initialValue()

返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，并且仅执行1次。ThreadLocal中的缺省实现直接返回一个null。

值得一提的是，在JDK5.0中，ThreadLocal已经支持泛型，该类的类名已经变为ThreadLocal<T>。API方法也相应进行了调整，新版本的API方法分别是void set(T value)、T get()以及T initialValue()。

 

ThreadLocal的使用

（1）自己写了一个多线程的：

public class SequenceNumber {
 // 通过匿名内部类ThreadLocal的initalValue方法指定初始值
 private static ThreadLocal seqNum = new ThreadLocal() {
  protected Object initialValue() {
   return new Integer(0);
  };
 };

 // 获得下一个序列值
 public int getNextNum() { 
  seqNum.set(new Integer(Integer.parseInt(seqNum.get().toString()) + 1));
  return Integer.parseInt(seqNum.get().toString());
 }

 public static void main(String[] args) {
  SequenceNumber sn = new SequenceNumber();
  TestClient t1 = new TestClient(sn);
  TestClient t2 = new TestClient(sn);
  TestClient t3 = new TestClient(sn);
  t1.start();
  t2.start();
  t3.start();
 }

 private static class TestClient extends Thread {
  private SequenceNumber sn;

  public TestClient(SequenceNumber sn) {
   this.sn = sn;
  }

  public void run() {
   for (int i = 0; i < 3; i++) {
    System.out.println("thread[" + Thread.currentThread().getName()
      + "]===sn[" + sn.getNextNum()+ "]");
   }
  }
 }
}

输出结果：

//------------------------------------------------------------------

thread[Thread-1]===sn[1]
thread[Thread-1]===sn[2]
thread[Thread-1]===sn[3]
thread[Thread-2]===sn[1]
thread[Thread-2]===sn[2]
thread[Thread-2]===sn[3]
thread[Thread-0]===sn[1]
thread[Thread-0]===sn[2]
thread[Thread-0]===sn[3]
//------------------------------------------------------------------

 

 

 

 

但是本人觉得这个不足以说明他是解决多线程并发的问题。

 

 

 

 （2）下面的两个是在网上摘抄的：

　　Hibernate的文档时看到了关于使ThreadLocal管理多线程访问的部分。具体代码如下

　　1. public static final ThreadLocal session = new ThreadLocal();

　　2. public static Session currentSession() {

　　3. Session s = (Session)session.get();

　　4. //open a new session,if this session has none

　　5. if(s == null){

　　6. s = sessionFactory.openSession();

　　7. session.set(s);

　　8. }

　　return s;

　　9. }

　　我们逐行分析

　　1。 初始化一个ThreadLocal对象，ThreadLocal有三个成员方法 get()、set()、initialvalue()。

　　如果不初始化initialvalue，则initialvalue返回null。

　　3。session的get根据当前线程返回其对应的线程内部变量，也就是我们需要的net.sf.hibernate.Session（相当于对应每个数据库连接）.多线程情况下共享数据库链接是不安全的。ThreadLocal保证了每个线程都有自己的s（数据库连接）。

　　5。如果是该线程初次访问，自然，s（数据库连接）会是null，接着创建一个Session，具体就是行6。

　　6。创建一个数据库连接实例 s

　　7。保存该数据库连接s到ThreadLocal中。

　　8。如果当前线程已经访问过数据库了，则从session中get()就可以获取该线程上次获取过的连接实例。

（3）　当要给线程初始化一个特殊值时，需要自己实现ThreadLocal的子类并重写该方法，通常使用一个内部匿名类对ThreadLocal进行子类化，EasyDBO中创建jdbc连接上下文就是这样做的：

　　public class JDBCContext{

　　private static Logger logger = Logger.getLogger(JDBCContext.class);

　　private DataSource ds;

　　protected Connection connection;

　　private boolean isValid = true;

　　private static ThreadLocal jdbcContext;

　　private JDBCContext(DataSource ds){

　　this.ds = ds;

　　createConnection();

　　}

　　public static JDBCContext getJdbcContext(javax.sql.DataSource ds)

　　{

　　if(jdbcContext==null)jdbcContext=new JDBCContextThreadLocal(ds);

　　JDBCContext context = (JDBCContext) jdbcContext.get();

　　if (context == null) {

　　context = new JDBCContext(ds);

　　}

　　return context;

　　}

　　private static class JDBCContextThreadLocal extends ThreadLocal {

　　public javax.sql.DataSource ds;

　　public JDBCContextThreadLocal(javax.sql.DataSource ds)

　　{

　　this.ds=ds;

　　}

　　protected synchronized Object initialValue() {

　　return new JDBCContext(ds);

　　}

　　}

　　}