ThreadLocal实现线程安全

时间 2019-11-24

原文原文链接

Spring经过各类模板类下降了开发者使用各类数据持久技术的难度。这些模板类都是线程安全的，也就是说，多个DAO能够复用同一个模板实例而不会发生冲突。咱们使用模板类访问底层数据，根据持久化技术的不一样，模板类须要绑定数据链接或会话的资源。但这些资源自己是非线程安全的，也就是说它们不能在同一时刻被多个线程共享。虽然模板类经过资源池获取数据链接或会话，但资源池自己解决的是数据链接或会话的缓存问题，并不是数据链接或会话的线程安全问题。
按照传统经验，若是某个对象是非线程安全的，在多线程环境下，对对象的访问必须采用synchronized进行线程同步。但模板类并未采用线程同步机制，由于线程同步会下降并发性，影响系统性能。此外，经过代码同步解决线程安全的挑战性很大，可能会加强好几倍的实现难度。那么模板类究竟仰仗何种魔法神功，能够在无须线程同步的状况下就化解线程安全的难题呢？答案就是ThreadLocal！
ThreadLocal在Spring中发挥着重要的做用，在管理request做用域的Bean、事务管理、任务调度、AOP等模块都出现了它们的身影，起着举足轻重的做用。java

ThreadLocal是什么

早在JDK 1.2的版本中就提供java.lang.ThreadLocal，ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。使用这个工具类能够很简洁地编写出优美的多线程程序。
ThreadLocal，顾名思义，它不是一个线程，而是线程的一个本地化对象。当工做于多线程中的对象使用ThreadLocal维护变量时，ThreadLocal为每一个使用该变量的线程分配一个独立的变量副本。因此每个线程均可以独立地改变本身的副本，而不会影响其余线程所对应的副本。从线程的角度看，这个变量就像是线程的本地变量，这也是类名中“Local”所要表达的意思。

线程局部变量并非Java的新发明，不少语言（如IBM XL、FORTRAN）在语法层面就提供线程局部变量。在Java中没有提供语言级支持，而以一种变通的方法，经过ThreadLocal的类提供支持。因此，在Java中编写线程局部变量的代码相对来讲要笨拙一些，这也是为何线程局部变量没有在Java开发者中获得很好普及的缘由。缓存

ThreadLocal的接口方法

ThreadLocal类接口很简单，只有4个方法，咱们先来了解一下。安全

void set(Object value) 设置当前线程的线程局部变量的值；
public Object get() 该方法返回当前线程所对应的线程局部变量；
public void remove() 将当前线程局部变量的值删除，目的是为了减小内存的占用，该方法是JDK 5.0新增的方法。须要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，因此显式调用该方法清除线程的局部变量并非必须的操做，但它能够加快内存回收的速度；
protected Object initialValue() 返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，而且仅执行1次。ThreadLocal中的默认实现直接返回一个null。

值得一提的是，在JDK5.0中，ThreadLocal已经支持泛型，该类的类名已经变为ThreadLocal<T>。API方法也相应进行了调整，新版本的API方法分别是void set(T value)、T get()以及T initialValue()。

ThreadLocal是如何作到为每个线程维护变量的副本的呢？其实实现的思路很简单：在ThreadLocal类中有一个Map，用于存储每个线程的变量副本，Map中元素的键为线程对象，而值对应线程的变量副本。多线程

一个TheadLocal实例
咱们经过一个具体的实例了解一下ThreadLocal的具体使用方法。
并发

package cn.chinotan.service.thredLocal;

import com.google.common.util.concurrent.ThreadFactoryBuilder;

import java.util.concurrent.*;

/**
 * @program: test
 * @description: thredLocalDemo
 * @author: xingcheng
 * @create: 2018-09-09 17:13
 **/
public class ThreadLocalDemo {

    static ThreadLocal<Integer> count = new ThreadLocal<Integer>(){
        // 进行初始化
        @Override
        protected Integer initialValue() {
            return 0;
        }
    };

    static Integer countRef = 0;

    private Integer getNextCount() {
        count.set(count.get() + 1);
        return count.get();
    }

    private Integer getNextCountRef() {
        countRef = countRef + 1;
        return countRef;
    }
    
    public static void main(String[] args) {
        ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
                .setNameFormat("demo-pool-%d").build();
        ExecutorService executorService = new ThreadPoolExecutor(10, 10,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(), namedThreadFactory);

        ThreadLocalDemo threadLocalDemo = new ThreadLocalDemo();
        executorService.execute(new CountRun(threadLocalDemo));
        executorService.execute(new CountRun(threadLocalDemo));
        executorService.execute(new CountRun(threadLocalDemo));
        
        // 参照
        ThreadLocalDemo threadLocalDemoRef = new ThreadLocalDemo();
        executorService.execute(new CountRunRef(threadLocalDemoRef));
        executorService.execute(new CountRunRef(threadLocalDemoRef));
        executorService.execute(new CountRunRef(threadLocalDemoRef));

        executorService.shutdown();
    }
    
    static class CountRun implements Runnable{

        private ThreadLocalDemo demo;

        public CountRun(ThreadLocalDemo dem) {
            demo = dem;
        }

        @Override
        public void run() {
            for(int i = 0; i < 3; i++){
                System.out.println("thread[" + Thread.currentThread().getName()+ "] count [" + demo.getNextCount() + "]");
            }
        }
    }

    static class CountRunRef extends Thread{

        private ThreadLocalDemo demo;

        public CountRunRef(ThreadLocalDemo dem) {
            demo = dem;
        }

        @Override
        public void run() {
            for(int i = 0; i < 3; i++){
                System.out.println("threadRef[" + Thread.currentThread().getName()+ "] count [" + demo.getNextCountRef() + "]");
            }
        }
    }
}

输出：ide

考查输出的结果信息，咱们发现每一个线程所产生的序号虽然都共享同一个Sequence Number实例，但它们并无发生相互干扰的状况，而是各自产生独立的序列号，这是由于咱们经过ThreadLocal为每个线程提供了单独的副本。

与Thread同步机制的比较

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

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

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

因为ThreadLocal中能够持有任何类型的对象，低版本JDK所提供的get()返回的是Object对象，须要强制类型转换。但JDK 5.0经过泛型很好的解决了这个问题，在必定程度上简化ThreadLocal的使用，代码清单9-2就使用了JDK 5.0新的ThreadLocal<T>版本。

归纳起来讲，对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式：访问串行化，对象共享化。而ThreadLocal采用了“以空间换时间”的方式：访问并行化，对象独享化。前者仅提供一份变量，让不一样的线程排队访问，然后者为每个线程都提供了一份变量，所以能够同时访问而互不影响。

Spring使用ThreadLocal解决线程安全问题

咱们知道在通常状况下，只有无状态的Bean才能够在多线程环境下共享，在Spring中，绝大部分Bean均可以声明为singleton做用域。就是由于Spring对一些Bean（如RequestContextHolder、TransactionSynchronizationManager、LocaleContextHolder等）中非线程安全的“状态性对象”采用ThreadLocal进行封装，让它们也成为线程安全的“状态性对象”，所以有状态的Bean就可以以singleton的方式在多线程中正常工做了。工具

通常的Web应用划分为展示层、服务层和持久层三个层次，在不一样的层中编写对应的逻辑，下层经过接口向上层开放功能调用。在通常状况下，从接收请求到返回响应所通过的全部程序调用都同属于一个线程，这样用户就能够根据须要，将一些非线程安全的变量以ThreadLocal存放，在同一次请求响应的调用线程中，全部对象所访问的同一ThreadLocal变量都是当前线程所绑定的。性能