ThreadLocal概念

最新推荐文章于 2022-11-03 20:47:27 发布

alice_nn

最新推荐文章于 2022-11-03 20:47:27 发布

阅读量249

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/alice_nn/article/details/103761724

版权

Java 专栏收录该内容

47 篇文章 1 订阅

订阅专栏

一、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

thread-0

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

上面的test中的LongLocal和StringLocal都是重写了initvalue方法的，所以在main方法中先进行getXXX时没有报异常。
————————————————
版权声明：本文为CSDN博主「dakaniu」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/dakaniu/article/details/80829079

alice_nn

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ThreadLocal概念

一、ThreadLocal概念ThreadLocal 是线程的局部变量，是每一个线程所单独持有的，其他线程不能对其进行访问。当使用ThreadLocal维护变量的时候为每一个使用该变量的线程提供一个独立的变量副本，即每个线程内部都会有一个该变量，这样同时多个线程访问该变量并不会彼此相互影响，因此他们使用的都是自己从内存中拷贝过来的变量的副本，这样就不存在线程安全问题，也不会影响程序的执行...
复制链接

扫一扫