java中thread的使用 java中threadlocal用法

1、ThreadLocal简介

在涉及到多线程需要共享变量的时候，容易出现并发问题，特别是在多个线程需要对一个共享变量进行写入时。为了保证线程安全，一般使用者在访问共享变量时需要进行适当的同步。同步的措施一般是加锁，是得在每个时刻只能有一个线程访问该变量，好处就是便于编码，缺点在于增加了线程间的竞争，降低了效率；第二个是使用ThreadLocal。如果说synchronized是以“时间换空间”，那么ThreadLocal就是以“空间换时间”，因为ThreadLocal的原理就是：对于要在线程间共享的变量，为每个线程都提供一个这样的变量，使得这些变量是线程级别的变量，不同线程之间互不影响，从而达到可以并发访问而不出现并发问题的目的。

ThreadLocal是JDK包提供的，它提供了线程本地变量，也就说当你创建了一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个本地副本。当多个线程操作这个变量时，实际操作的是自己本地内存里面的变量，从而避免了线程安全问题。创建一个ThreadLocal变量后，每个线程都会复制一个变量到自己的本地内存。

2、ThreadLocal使用示例

// 多线程访问一个共享变量时特别容易出现并发问题，特别是在多线程需要对一个共享变量进行写入时
// threadLocal可以在使用者访问共享变量时进行适当的的同步
public class ThreadLocalTest {
    // print 函数
    static void print(String str) {
        // 1.1 打印当前线程本地内存中localVariable变量的值
        System.out.println(str + ":" + localVariable.get());
        // 1.2 清除当前线程本地内存中的localVariable变量
        localVariable.remove();
    }

    // 2 创建threadLocal变量
    static ThreadLocal<String> localVariable = new ThreadLocal<>();
    public static void main(String[] args) {
        // 3 创建线程one
        Thread threadOne = new Thread(new Runnable() {
            @Override
            public void run() {
                // 3.1 设置线程One 中本地变量localVariable的值
                localVariable.set("threadOne local variable");
                // 3.2 调用打印函数
                print("threadOne");
                // 3.3 打印本地变量值
                System.out.println("threadOne remove after" + ":" + localVariable.get());
            }
        });

        // 4 创建线程two
        Thread threadTwo = new Thread(new Runnable() {
            @Override
            public void run() {
                // 4.1 设置线程Two中本地变量localVariable的值
                localVariable.set("threadTwo local variable");
                // 4.2 调用打印函数
                print("threadTwo");
                // 4.3 打印本地变量值
                System.out.println("threadTwo remove after" + ":" + localVariable.get());
            }
        });

        // 5 启动线程
        threadOne.start();
        threadTwo.start();
    }

}

执行程序：

threadOne:threadOne local variable
threadTwo:threadTwo local variable
threadOne remove after:threadOne local variable
threadTwo remove after:threadTwo local variable

Process finished with exit code 0

3、ThreadLocal实现原理

首先看一下ThreadLocal相关类的类图结构:

 由该图可知，Thread类中有一个threadLocals和一个inheritableThreadLocals，它们都是ThreadLocalMap类型的变量，而ThreadLocalMap是一个定制化的Hashmap。在默认情况下，每个线程中的这两个变量都为null，只有当前线程第一次调用ThreadLocal的set或者get方法时才会创建它们。其实每个线程的本地变量不是存放在ThreadLocal实例里面，而是存放在调用线程的threadLocals变量里面。也就说，ThreadLocal类型的本地变量存放在具体的线程内存空间中。

ThreadLocal就是一个工具壳，它通过set方法把value值放入调用线程的threadLocals里面并存放起来，当调用线程调用它的get方法时，再从当前线程的threadLocals变量里面将其拿出来使用。如果调用线程一直不终止，那么这个本地变量会一直存放在调用线程的threadLocals变量里面，所以当不需要使用本地变量时可以通过调用ThreadLocal变量的remove方法，从当前线程的threadLocals里面删除该本地变量。

3.1、set方法源码分析

public void set(T value) {
        // 获取当前线程
        Thread t = Thread.currentThread();
        // 将当前线程作为key，去查找对应的线程变量，找到则设置
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            map.set(this, value);
        } else {
            // 第一次调用就创建当前线程的HashMap
            createMap(t, value);
        }
    }

3.2、get方法源码分析

public T get() {
        // 获取当前线程
        Thread t = Thread.currentThread();
        // 获取当前线程的threadLocals变量
        ThreadLocalMap map = getMap(t);
        // 如果threadLocals不为null,则返回对应本地变量的值
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        // threadLocals为空则初始化当前线程的threadLocals成员变量
        return setInitialValue();
    }

private T setInitialValue() {
        // 初始化为Null
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        // 如果当前线程的threadLocals变量不为空
        if (map != null) {
            map.set(this, value);
        } else {
            // 如果当前线程的threadLocals变量为空
            createMap(t, value);
        }
        if (this instanceof TerminatingThreadLocal) {
            TerminatingThreadLocal.register((TerminatingThreadLocal<?>) this);
        }
        return value;
    }

3.3、remove方法源码分析

public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         // 如果当前线程的threadLocals变量不为空，则删除当前线程中指定ThreadLocal实例的本地变量
         if (m != null) {
             m.remove(this);
         }
     }

如上图所示，在每个线程内部都有一个名为threadLocals的成员变量，该变量的类型为HashMap，其中key为我们定义的ThreadLocal变量的this引用，value则为我们使用set方法设置的值。每个线程的本地变量存放在线程自己的内存变量threadLocals中，如果当前线程一直不消亡，那么这些本地变量会一直存在，所以可能会造成内存溢出，因此使用完毕后要调用remove方法删除对应线程的threadLocals中的本地变量。

4、threadLocal不支持继承性

public class TestThreadLocal {
    // 创建线程变量
    public static ThreadLocal<String> threadLocal = new ThreadLocal<String>();
    public static void main(String[] args) {
        // 设置线程变量
        threadLocal.set("hello world");
        // 启动子线程
        Thread thread = new Thread(new Runnable() {
            public void run() {
                // 子线程输出线程变量的值
                System.out.println("thread:" + threadLocal.get());
            }
        });
        thread.start();
        // 主线程输出线程变量的值
        System.out.println("main:" + threadLocal.get());
    }
}

执行程序：

main:hello world
thread:null

5、inheritableThreadLocal类

InheritableThreadLocal继承自ThreadLocal，其提供了一个特性，就是让子线程可以访问在父线程中设置的本地变量。

把第四节中创建线程的变量修改为：

// 创建线程变量
public static ThreadLocal<String> threadLocal = new InheritableThreadLocal<String>();

运行结果：

thread:hello world
main:hello world