频道栏目
首页 > 程序开发 > 软件开发 > Java > 正文
ThreadLocal
2011-12-08 14:51:19      个评论      
收藏   我要投稿

 

ThreadLocal是什么呢?其实ThreadLocal不是一个线程的本地实现版本,也不是一个Thread。

ThreadLocal的目的就是为每一个使用ThreadLocal的线程都提供一个值,

让该值和使用它的线程绑定,当然每一个线程都可以独立地改变它绑定的值。

主要函数

Public Methods

T get()

Returns the value of this variable for the current thread.

返回当前线程的线程局部变量副本

void remove()

Removes the entry for this variable in the current thread.

如果我们想把ThreadLocal所绑定的对象的引用清空,请不要粗暴的把ThreadLocal设置null,而应该调用remove()方法

void set(T value)

Sets the value of this variable for the current thread.

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

 

Protected Methods

T initialValue()

Provides the initial value of this variable for the current thread.

该方法返回当前线程在该线程局部变量的初始值。这个方法是一个延迟调用方法,在一个线程第1次调用get()且此时还没调用set(Object)时才执行,并且仅执行1次。ThreadLocal中返回的是null。该方法是一个protected的方法,它主要是为设置局部变量的初始值提供方便。

 

 ThreadLocal是如何做到让每一个线程和一个值绑定的呢?

其实实现的思路很简单,在ThreadLocal类中有一个Map,用于存储每一个线程的变量的副本。

比如下面的示例实现:

示例1:

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;

  }

}

注意:以上只是一个粗略的实现。我觉得上面的没有必要使用Collections.synchronizedMap。

因为不同的线程不可能对HashMap的同一项进行操作。

在JDK中的ThreadLocal的实现感觉很巧妙:

下面是去掉了注释后ThreadLocal的代码

public class ThreadLocal<T> {

    private final int threadLocalHashCode = nextHashCode();

       private static AtomicInteger nextHashCode =

        new AtomicInteger();

    private static final int HASH_INCREMENT = 0x61c88647;

   private static int nextHashCode() {

        return nextHashCode.getAndAdd(HASH_INCREMENT);

    }

    protected T initialValue() {

        return null;

    }

    public ThreadLocal() {

    }

       public T get() {

        Thread t = Thread.currentThread();

        ThreadLocalMap map = getMap(t);

        if (map != null) {

            ThreadLocalMap.Entry e = map.getEntry(this);

            if (e != null)

                return (T)e.value;

        }

        return setInitialValue();

    }

    private T setInitialValue() {

        T value = initialValue();

        Thread t = Thread.currentThread();

        ThreadLocalMap map = getMap(t);

        if (map != null)

            map.set(this, value);

        else

            createMap(t, value);

        return value;

    }

    public void set(T value) {

        Thread t = Thread.currentThread();

        ThreadLocalMap map = getMap(t);

        if (map != null)

            map.set(this, value);

        else

            createMap(t, value);

    }

     public void remove() {

         ThreadLocalMap m = getMap(Thread.currentThread());

         if (m != null)

             m.remove(this);

     }

    ThreadLocalMap getMap(Thread t) {

        return t.threadLocals;

    }

    void createMap(Thread t, T firstValue) {

        t.threadLocals = new ThreadLocalMap(this, firstValue);

    }

    static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {

        return new ThreadLocalMap(parentMap);

    }

       T childValue(T parentValue) {

        throw new UnsupportedOperationException();

    }

注意1:每个线程有个ThreadLocalMap threadLocals,它是把ThreadLocal作为threadLocals键值在使用的。这点比示例1的算法先进多。它没有了同步问题。因为它被创建后根本就没读写操作。

注意2:ThreadLocalMap就在ThreadLocal中,但是它并没有使用HashMap,它使用的算法有复杂,没看明白。

注意3:如果我们对hashcode不是通过该对象的成员生成,而是使其自动生成时,且采用取余形式得到哈希值,增量(HASH_INCREMENT)最好是个素数。这样增量的才不能被任何才小于取余值(哈希表的长度)整除,否则会哈希到同一个桶中。

ThreadLocalMap中就是对hashcode取余的方式得到哈希值的。

int len = tab.length;

int i = key.hashCode & (len-1);

因为

  /**

   * The initial capacity -- MUST be a power of two.

   */

  private static final int INITIAL_CAPACITY = 16;

所以上面的"int i = key.hashCode & (len-1);"相当于"int i = key.hashCode %len;"

虽然"HASH_INCREMENT"不是个素数,但是它却不能被tab.length(它等于2的n此方且大于等于16)被整除的。

注意4:ThreadLocalMap中采用的是弱引用

        static class Entry extends WeakReference<ThreadLocal> {

            /** The value associated with this ThreadLocal. */

            Object value;

 

            Entry(ThreadLocal k, Object v) {

                super(k);

                value = v;

            }

        }

注意5:JDK为什么不使用hashMap或WeakHashMap,而是自己写了ThreadLocalMap。应该主要是为提供了对不同key(这里是ThreadLocal)对象的但hashCode相同的存储的支持。

如果希望线程局部变量初始化其它值,那么需要自己实现ThreadLocal的子类并重写initialValue()该方法,

通常使用一个内部匿名类对ThreadLocal进行子类化,比如下面的例子,SerialNum类为每一个类分配一个序号:

Java代码

 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的,所以在需要获取当前线程的序号时,简单地调用:

Java代码

    int serial = SerialNum.get();

即可。

使用方法一

Hibernate的文档中关于使ThreadLocal管理多线程访问的部分。

具体代码如下

  public static final ThreadLocal session = new ThreadLocal();

  public static Session currentSession() {

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

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

   if(s == null){

      s = sessionFactory.openSession();

      session.set(s);

   }

      return s;

 }

我们逐行分析

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()就可以获取该线程上次获取过的连接实例。

使用方法二

当要给线程初始化一个特殊值时,需要自己实现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);

    jdbcContext.set(context);

  }

  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);

  }

 }

}

使用单例模式,不同的线程调用getJdbcContext()获得自己的jdbcContext,

都是通过JDBCContextThreadLocal内置子类来获得JDBCContext对象的线程局部变量

总结

    ThreadLocal和同步机制,两者面向的问题领域不同。

    同步机制是为了同步多个线程对相同资源的并发访问,是为了多个线程之间进行通信的有效方式;    而ThreadLocal是隔离多个线程的数据共享,从根本上就不在多个线程之间共享资源(变量),这样当然不需要对多个线程进行同步了。

    所以,如果你需要进行多个线程之间进行通信,则使用同步机制;如果需要隔离多个线程之间的共享冲突,可以使用ThreadLocal,这将极大地简化你的程序,使程序更加易读、简洁。

 

如果我们想把ThreadLocal所绑定的对象的引用清空,请不要粗暴的把ThreadLocal引用设置null,而应该调用remove()方法。否则会造成内存泄露。关于此的更多内容请参考《ThreadLocal的内存泄露》

点击复制链接 与好友分享!回本站首页
相关TAG标签
上一篇:servlet中写入和读取删除cookie
下一篇:为ThreadLocal定制的ThreadLocalMap
相关文章
图文推荐
点击排行

关于我们 | 联系我们 | 广告服务 | 投资合作 | 版权申明 | 在线帮助 | 网站地图 | 作品发布 | Vip技术培训 | 举报中心

版权所有: 红黑联盟--致力于做实用的IT技术学习网站