ThreadLocal原理

一、ThreadLocal概念

ThreadLocal 是线程的局部变量, 是每一个线程所单独持有的,其他线程不能对其进行访问。

当使用ThreadLocal维护变量的时候 为每一个使用该变量的线程提供一个独立的变量副本,即每个线程内部都会有一个该变量,这样同时多个线程访问该变量并不会彼此相互影响,因此他们使用的都是自己从内存中拷贝过来的变量的副本, 这样就不存在线程安全问题,也不会影响程序的执行性能。

但是要注意,虽然ThreadLocal能够解决上面说的问题,但是由于在每个线程中都创建了副本,所以要考虑它对资源的消耗,比如内存的占用会比不使用ThreadLocal要大。

二、与线程同步机制相比较

ThreadLocal和线程同步机制相比有什么优势呢?ThreadLocal和线程同步机制都是为了解决多线程中相同变量的访问冲突问题。

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

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

  由于ThreadLocal中可以持有任何类型的对象,低版本JDK所提供的get()返回的是Object对象,需要强制类型转换。但JDK 5.0新的ThreadLocal版本通过泛型很好的解决了这个问题,在一定程度地简化ThreadLocal的使用。

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

三、ThreadLocal的具体体现

先了解一下ThreadLocal类提供的几个方法:

public T get() { } // 用来获取ThreadLocal在当前线程中保存的变量副本

public void set(T value) { } //set()用来设置当前线程中变量的副本

public void remove() { } //remove()用来移除当前线程中变量的副本

protected T initialValue() { } //initialValue()是一个protected方法,一般是用来在使用时进行重写的

在这个方法内部我们看到,首先通过getMap(Thread t)方法获取一个和当前线程相关的ThreadLocalMap,然后将变量的值设置到这个ThreadLocalMap对象中,当然如果获取到的ThreadLocalMap对象为空,就通过createMap方法创建。这里的this是指向threadlocal实例对象的。

其中ThreadLocal类中的get方法源码实现如下:

/**

  • Returns the value in the current thread's copy of this
  • thread-local variable. If the variable has no value for the
  • current thread, it is first initialized to the value returned
  • by an invocation of the {@link #initialValue} method.
  • @return the current thread's value of this thread-local */
    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();
    }
    第一句是取得当前线程,然后通过getMap(t)方法获取到一个map,map的类型为ThreadLocalMap。获取和当前线程绑定的值时,ThreadLocalMap对象是以this指向的ThreadLocal对象为键进行查找的 所以通过ThreadLocalMap的Entry获取到<key,value>键值对

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

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

  我们上面的每一句来仔细分析:首先看一下getMap方法中做了什么:

/**

  • Get the map associated with a ThreadLocal. Overridden in
  • InheritableThreadLocal.
  • @param t the current thread
  • @return the map */
    ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
    }
    在getMap中,是调用当期线程t,返回当前线程t中的一个成员变量threadLocals

Thread类中的成员变量threadLocals是什么?源码如下:

ThreadLocal.ThreadLocalMap threadLocals = null; threadLocals是一个ThreadLocalMap,这个类型是ThreadLocal类的一个内部类,ThreadLocalMap的实现如下

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

        Entry(ThreadLocal k, Object v) {
            super(k);
            value = v;
        }
    }

... } 可以看到ThreadLocalMap的Entry继承了WeakReference,并且使用ThreadLocal作为键值。

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

/** * Variant of set() to establish initialValue. Used instead * of set() in case user has overridden the set() method. * * @return the initial value */
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;
}

/**
 * Provides the initial value of this variable for the current thread.
 * The default implementation returns {@code null}.
 *
 * @return the initial value of the variable.
 */
protected T initialValue() {
    return null;
}

如果map不为空,就设置键值对,如果map为空,调用createMap,createMap的实现

/**

  • Create the map associated with a ThreadLocal. Overridden in
  • InheritableThreadLocal.
  • @param t the current thread
  • @param firstValue value for the initial entry of the map
  • @param map the map to store. */
    void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
    } ThreadLocalMap是ThreadLocal类的一个静态内部类,它实现了键值对的设置和获取,每个线程中都有一个独立的ThreadLocalMap副本,它所存储的值,只能被当前线程读取和修改。ThreadLocal类通过操作每一个线程特有的ThreadLocalMap副本,从而实现了变量访问在不同线程中的隔离。因为每个线程的变量都是自己特有的,完全不会有并发错误。还有一点就是,ThreadLocalMap存储的键值对中的键是this对象指向的ThreadLocal对象,而值就是你所设置的对象了。

这个时候再看set方法就简单多了,源码如下:

/** * Sets the current thread's copy of this thread-local variable * to the specified value. Most subclasses will have no need to * override this method, relying solely on the {@link #initialValue} * method to set the values of thread-locals. * * @param value the value to be stored in the current thread's copy of * this thread-local. */
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
在这个方法内部我们看到,首先通过getMap(Thread t)方法获取一个和当前线程相关的ThreadLocalMap,然后将变量的值设置到这个ThreadLocalMap对象中,其中以this指向的threadlocal对象为健值,当然如果获取到的ThreadLocalMap对象为空,就通过createMap方法创建。

总结一下:

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

  2)为何threadLocals的类型ThreadLocalMap的键值为ThreadLocal对象,因为每个线程中可有多个threadLocal变量;

  3)在进行get之前,必须先set,否则会报空指针异常;因为在上面的代码分析过程中,我们发现如果没有先set的话,即在map中查找不到对应的存储,则会通过调用setInitialValue方法返回i,而在setInitialValue方法中,有一个语句是T value = initialValue(), 而默认情况下,initialValue方法返回的是null。

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

四、ThreadLocal例子

public class Test { ThreadLocal longLocal = new ThreadLocal(){ protected Long initialValue() { return Thread.currentThread().getId(); }; }; ThreadLocal stringLocal = new ThreadLocal(){; 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 Test test = new Test();
 
    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());
}

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

    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

8

thread-0

共享变量test在主线程和thread1线程中,各自有一个threadlocalmap来存储该变量的副本,各自的threadlocalmap将把共享变量test中的LongLocal和StringLocal的对象作为健,以thread的id 和name为值进行存储。

上面的test中的LongLocal和StringLocal都是重写了initvalue方法的,所以在main方法中先进行getXXX时没有报异常。

原文链接:https://blog.csdn.net/dakaniu/article/details/80829079


已有 0 条评论

    欢迎您,新朋友,感谢参与互动!