//ThreadLocal类提供的方法
1 public T get() {}           //get()方法是用来获取ThreadLocal在当前线程中保存的变量副本
2 public void set(T value) {}     //set()用来设置当前线程中变量的副本
3 public void remove() {}        //remove()用来移除当前线程中变量的副本
4 protected T initialValue() {}    //initialValue()是一个protected方法,一般是用来在使用时进行重写的,它是一个延迟加载方法

威尼斯人线上娱乐,从这个类的名字就能大体了解到类的作用,ThreadLocal可以分解为Thread和Local,前者就不多说了,后者的意思是局部,本地的意思,整个类名可以理解为:线程局部对象或线程本地变量。程序是运行在线程中的,所以,在整个运行过程中,在任何地方都可以获得这个线程的局部对象,ThreadLocal类型的变量是和线程相绑定的。

 

1.ThreadLocal源码

先来看一下涉及到的类图:

威尼斯人线上娱乐 1

public T get() {} // 获取ThreadLocal在当前线程中保存的变量副本
public void set(T value) {} //用来设置当前线程中变量的副本
private T setInitialValue(){} // 设置初始值
protected T initialValue(){} //得到初始值,一般是用来在使用时进行重写的
void createMap(Thread t, T firstValue) {}  // 在线程中对threadLocals成员变量赋值

get方法的实现如下:

    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

get方法首先取得当前线程,然后通过getMap(t)方法获取到一个map,map的类型为ThreadLocalMap。然后接着下面获取到<key,value>键值对,注意这里获取键值对传进去的是this,而不是当前线程t。如果获取成功,则返回value值。如果map为空,则调用setInitialValue方法返回value。
接下来看一下getMap方法的源码:

ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

在getMap中,是调用当期线程t,返回当前线程t中的一个成员变量threadLocals。
那就看一下Thread类是的threadLocals是什么。

ThreadLocal.ThreadLocalMap threadLocals = null;

实际上就是一个ThreadLocalMap,这个类型是ThreadLocal类的一个内部类,我们继续取看ThreadLocalMap的实现.

static class ThreadLocalMap {
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
...
}

这里只贴出部份源码,熟悉HashMap源码的同学很快就会反映到这和HashMap的实现非常类似,在这里我就暂且可以将ThreadLocalMap理解为一个Map,即键值对形式的数据结构。

然后看一下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;
    }

    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

   protected T initialValue() {
        return null;
    }

很容易了解,就是如果map不为空,就设置键值对。如果为空,就创建Map。在createMap方法里面以this(即ThreadLocal类型的变量)为值,以变量为键进行存储,即存储在当前线程中的threadLocals里面。同时源码中initialValue方法返回的是一个空值,所以我们在实际实用时为了防止空指针异常,在调用get方法前要么对initialValue方法进行重写,要么先调用set方法进行初始值的显示设置。下面看看set方法的源码:

public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

有了上面的分析,set方法还是很容易理解的。
现在对ThreadLocal是如何为每个线程创建变量的副本的作一个小的总结:

首先,在每个线程Thread内部有一个ThreadLocal.ThreadLocalMap类型的成员变量threadLocals,这个threadLocals就是用来存储实际的变量副本的,键值为当前ThreadLocal变量,value为变量副本(即T类型的变量)。

初始时,在Thread里面,threadLocals为空,当通过ThreadLocal变量调用get()方法或者set()方法,就会对Thread类中的threadLocals进行初始化,并且以当前ThreadLocal变量为键值,以ThreadLocal要保存的副本变量为value,存到threadLocals。

然后在当前线程里面,如果要使用副本变量,就可以通过get方法在threadLocals里面查找。

get方法的实现:

2.实例

  威尼斯人线上娱乐 2

2.1 实例一:在调用get前先要使用set进行设置
package com.hust.hebh.concurrency;

public class ThreadLocalTest {
    ThreadLocal<Long> longLocal = new ThreadLocal<Long>();
    ThreadLocal<String> stringLocal = new ThreadLocal<String>();


    public void set() {
        longLocal.set(Thread.currentThread().getId());
        stringLocal.set(Thread.currentThread().getName());
    }

    public long getLong() {
        return longLocal.get();
    }

    public String getString() {
        return stringLocal.get();
    }

    public static void main(String[] args) throws InterruptedException {
        final ThreadLocalTest test = new ThreadLocalTest();     

        test.set();
        System.out.println(test.getLong());
        System.out.println(test.getString());   

        Thread thread1 = new Thread(){
            public void run() {
                test.set();
                System.out.println(test.getLong());
                System.out.println(test.getString());
            };
        };
        thread1.start();
        thread1.join();

        System.out.println(test.getLong());
        System.out.println(test.getString());
    }
}

从这段代码的输出结果可以看出,在main线程中和thread1线程中,longLocal保存的副本值和stringLocal保存的副本值都不一样。最后一次在main线程再次打印副本值是为了证明在main线程中和thread1线程中的副本值确实是不同的。

总结一下:

1)实际的通过ThreadLocal创建的副本是存储在每个线程自己的threadLocals中的;

2)为何threadLocals的类型ThreadLocalMap的键值为ThreadLocal对象,因为每个线程中可有多个threadLocal变量,就像上面代码中的longLocal和stringLocal;

3)在进行get之前,必须先set,否则会报空指针异常;

如果想在get之前不需要调用set就能正常访问的话,必须重写initialValue()方法。

   第一句是取得当前线程,然后通过getMap(t)方法获取到一个map,map的类型为ThreadLocalMap。然后接着下面获取到<key,value>键值对,注意这里获取键值对传进去的是 
this,而不是当前线程t。

2.2 实例二,重写initialValue方法

在上面的代码分析过程中,我们发现如果没有先set的话,即在map中查找不到对应的存储,则会通过调用setInitialValue方法返回i,而在setInitialValue方法中,有一个语句是T
value = initialValue(),
而默认情况下,initialValue方法返回的是null。下面看看如何对initialValue方法进行重写

package com.hust.hebh.concurrency;

public class ThreadLocalDemo {
    ThreadLocal<Long> longLocal = new ThreadLocal<Long>(){
        protected Long initialValue() {
            return Thread.currentThread().getId();
        };
    };
    ThreadLocal<String> stringLocal = new ThreadLocal<String>(){;
        protected String initialValue() {
            return Thread.currentThread().getName();
        };
    };

    public void set() {
        longLocal.set(Thread.currentThread().getId());
        stringLocal.set(Thread.currentThread().getName());
    }

    public long getLong() {
        return longLocal.get();
    }

    public String getString() {
        return stringLocal.get();
    }

    public static void main(String[] args) throws InterruptedException {
        final ThreadLocalDemo test = new ThreadLocalDemo();

        //test.set();
        System.out.println(test.getLong());
        System.out.println(test.getString());   

        Thread thread1 = new Thread(){
            public void run() {
                //test.set();
                System.out.println(test.getLong());
                System.out.println(test.getString());
            };
        };
        thread1.start();
        thread1.join();

        System.out.println(test.getLong());
        System.out.println(test.getString());
    }
}

通过对对initialValue方法进行重写在不进行set的情况下就可以实现和实例一相同的效果。

  如果获取成功,则返回value值。

3. ThreadLocal的应用场景

最常见的ThreadLocal使用场景为 用来解决 数据库连接、Session管理等。

下面来看一个hibernate中典型的ThreadLocal的应用:

private static final ThreadLocal threadSession = new ThreadLocal();  

public static Session getSession() throws InfrastructureException {  
    Session s = (Session) threadSession.get();  
    try {  
        if (s == null) {  
            s = getSessionFactory().openSession();  
            threadSession.set(s);  
        }  
    } catch (HibernateException ex) {  
        throw new InfrastructureException(ex);  
    }  
    return s;  
}  

可以看到在getSession()方法中,首先判断当前线程中有没有放进去session,如果还没有,那么通过sessionFactory().openSession()来创建一个session,再将session
set到线程中,实际是放到当前线程的ThreadLocalMap这个map中,这时,对于这个session的唯一引用就是当前线程中的那个ThreadLocalMap(下面会讲到),而threadSession作为这个值的key,要取得这个session可以通过threadSession.get()来得到,里面执行的操作实际是先取得当前线程中的ThreadLocalMap,然后将threadSession作为key将对应的值取出。这个session相当于线程的私有变量,而不是public的。
显然,其他线程中是取不到这个session的,他们也只能取到自己的ThreadLocalMap中的东西。要是session是多个线程共享使用的,那还不乱套了。
试想如果不用ThreadLocal怎么来实现呢?可能就要在action中创建session,然后把session一个个传到service和dao中,这可够麻烦的。或者可以自己定义一个静态的map,将当前thread作为key,创建的session作为值,put到map中,应该也行,这也是一般人的想法,但事实上,ThreadLocal的实现刚好相反,它是在每个线程中有一个map,而将ThreadLocal实例作为key,这样每个map中的项数很少,而且当线程销毁时相应的东西也一起销毁了,不知道除了这些还有什么其他的好处。

总之,ThreadLocal不是用来解决对象共享访问问题的,而主要是提供了保持对象的方法和避免参数传递的方便的对象访问方式。归纳了两点:
1。每个线程中都有一个自己的ThreadLocalMap类对象,可以将线程自己的对象保持到其中,各管各的,线程可以正确的访问到自己的对象。
2。将一个共用的ThreadLocal静态实例作为key,将不同对象的引用保存到不同线程的ThreadLocalMap中,然后在线程执行的各处通过这个静态ThreadLocal实例的get()方法取得自己线程保存的那个对象,避免了将这个对象作为参数传递的麻烦。

当然如果要把本来线程共享的对象通过ThreadLocal.set()放到线程中也可以,可以实现避免参数传递的访问方式,但是要注意get()到的是那同一个共享对象,并发访问问题要靠其他手段来解决。但一般来说线程共享的对象通过设置为某类的静态变量就可以实现方便的访问了,似乎没必要放到线程中。

ThreadLocal的应用场合,我觉得最适合的是按线程多实例(每个线程对应一个实例)的对象的访问,并且这个对象很多地方都要用到。

  如果map为空,则调用setInitialValue方法返回value。

分析:

  首先看一下getMap方法中做了什么:

  威尼斯人线上娱乐 3

  在getMap中,是调用当期线程t,返回当前线程t中的一个成员变量threadLocals。

  取Thread类中取看一下成员变量threadLocals是什么:

  威尼斯人线上娱乐 4

  实际上就是一个ThreadLocalMap,这个类型是ThreadLocal类的一个内部类,继续取看ThreadLocalMap的实现:

  威尼斯人线上娱乐 5

  可以看到ThreadLocalMap的Entry继承了WeakReference,并且使用ThreadLocal作为键值。然后再继续看setInitialValue方法的具体实现:

威尼斯人线上娱乐 6

  如果map不为空,就设置键值对,为空,再创建Map,看一下createMap的实现:

  威尼斯人线上娱乐 7

网站地图xml地图