多线程之ThreadLocal类

深入研究java.lang.ThreadLocal类

0.前言

ThreadLocal(线程变量副本)
Synchronized实现内存共享，ThreadLocal为每个线程维护一个本地变量。
采用空间换时间，它用于线程间的数据隔离，为每一个使用该变量的线程提供一个副本，每个线程都可以独立地改变自己的副本，而不会和其他线程的副本冲突。
ThreadLocal类中维护一个Map，用于存储每一个线程的变量副本，Map中元素的键为线程对象，而值为对应线程的变量副本。
ThreadLocal在Spring中发挥着巨大的作用，在管理Request作用域中的Bean、事务管理、任务调度、AOP等模块都出现了它的身影。
Spring中绝大部分Bean都可以声明成Singleton作用域，采用ThreadLocal进行封装，因此有状态的Bean就能够以singleton的方式在多线程中正常工作了。

 

一、概述

 

ThreadLocal是什么呢？其实ThreadLocal并非是一个线程的本地实现版本，它并不是一个Thread，而是threadlocalvariable(线程局部变量)。也许把它命名为ThreadLocalVar更加合适。线程局部变量(ThreadLocal)其实的功用非常简单，就是为每一个使用该变量的线程都提供一个变量值的副本，是Java中一种较为特殊的线程绑定机制，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。

 

从线程的角度看，每个线程都保持一个对其线程局部变量副本的隐式引用，只要线程是活动的并且 ThreadLocal 实例是可访问的；在线程消失之后，其线程局部实例的所有副本都会被垃圾回收（除非存在对这些副本的其他引用）。

 

通过ThreadLocal存取的数据，总是与当前线程相关，也就是说，JVM 为每个运行的线程，绑定了私有的本地实例存取空间，从而为多线程环境常出现的并发访问问题提供了一种隔离机制。

 

ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单，在ThreadLocal类中有一个Map，用于存储每一个线程的变量的副本。

 

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

 

二、API说明

 

ThreadLocal()

          创建一个线程本地变量。

 

T get()

          返回此线程局部变量的当前线程副本中的值，如果这是线程第一次调用该方法，则创建并初始化此副本。

 

protected  T initialValue()

          返回此线程局部变量的当前线程的初始值。最多在每次访问线程来获得每个线程局部变量时调用此方法一次，即线程第一次使用 get() 方法访问变量的时候。如果线程先于 get 方法调用 set(T) 方法，则不会在线程中再调用 initialValue 方法。

 

   若该实现只返回 null；如果程序员希望将线程局部变量初始化为 null 以外的某个值，则必须为 ThreadLocal 创建子类，并重写此方法。通常，将使用匿名内部类。initialValue 的典型实现将调用一个适当的构造方法，并返回新构造的对象。

 

void remove()

          移除此线程局部变量的值。这可能有助于减少线程局部变量的存储需求。如果再次访问此线程局部变量，那么在默认情况下它将拥有其 initialValue。

 

void set(T value)

          将此线程局部变量的当前线程副本中的值设置为指定值。许多应用程序不需要这项功能，它们只依赖于 initialValue() 方法来设置线程局部变量的值。

 

在程序中一般都重写initialValue方法，以给定一个特定的初始值。

典型复写实例：

创建一个学生类：

/*
 * 学生类
 * 此处为一个bean
 */
public class Student {
    public int age = 0;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

主程序：

import java.util.Random;

/*
 * 多线程下测试程序
 */
public class ThreadLocalDemo implements Runnable {
    //创建线程局部变量studentLocal,在后面你会发现用来保存student对象
    private final static ThreadLocal studentLocal = new ThreadLocal();

    public static void main(String[] args) {
        ThreadLocalDemo td = new ThreadLocalDemo();
        //线程一
        Thread t1 = new Thread(td,"a");
        //线程二
        Thread t2 = new Thread(td,"b");
        t1.start();
        t2.start();
    }
    @Override
    public void run() {
        accessStudent();
        // TODO Auto-generated method stub
    }
    /*
     *实例业务方法，用来测试
     */
    public void accessStudent(){
        //获取当前线程的名字
        String currentThreadName = Thread.currentThread().getName();
        System.out.println(currentThreadName + " is running");
        //产生一个随机数并打印
        Random random = new Random();
        int age = random.nextInt(100);
        System.out.println("Tread " + currentThreadName + " set age to:" + age);
        //获取一个student对象，并将随机年龄插入到对象的属性中
        //获取对象的方式，采用本地获取对象
        Student student = getStudent();
        student.setAge(age);
        System.out.println("Thread " + currentThreadName + " 第一次读取年龄为：" + student.getAge());
        try {
            Thread.sleep(5000);

        } catch (InterruptedException ex) {
            ex.printStackTrace();

            // TODO: handle exception
        }
        System.out.println("Thread" + currentThreadName + " 第二次读取年龄为：" + student.getAge());
    }

       //此处为重点
    private Student getStudent() {
        //获取本线程变量并强制转换为Student类型
         Student student= (Student) studentLocal.get();
         //线程首次执行的时候，studentLocal.get()肯定为null
         if(student == null){
             //创建一个Student对象，并保存到本地的线程变量StudentLocal中
             student = new Student();
             studentLocal.set(student);

         }
        // TODO Auto-generated method stub
        return student;
    }
}

运行结果：

b is running
a is running
Tread b set age to:49
Tread a set age to:37
Thread b 第一次读取年龄为：49
Thread a 第一次读取年龄为：37
Thread b 第二次读取年龄为：49
Thread a 第二次读取年龄为：37

可以看到a、b两个线程age在不同时刻打印的值是完全相同的。这个程序通过妙用ThreadLocal，既实现多线程并发，游兼顾数据的安全性

四、总结

 

ThreadLocal使用场合主要解决多线程中数据数据因并发产生不一致问题。ThreadLocal为每个线程的中并发访问的数据提供一个副本，通过访问副本来运行业务，这样的结果是耗费了内存，单大大减少了线程同步所带来性能消耗，也减少了线程并发控制的复杂度。

 

ThreadLocal不能使用原子类型，只能使用Object类型。ThreadLocal的使用比synchronized要简单得多。

 

ThreadLocal和Synchonized都用于解决多线程并发访问。但是ThreadLocal与synchronized有本质的区别。synchronized是利用锁的机制，使变量或代码块在某一时该只能被一个线程访问。而ThreadLocal为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。而Synchronized却正好相反，它用于在多个线程间通信时能够获得数据共享。

 

Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。

 

当然ThreadLocal并不能替代synchronized,它们处理不同的问题域。Synchronized用于实现同步机制，比ThreadLocal更加复杂。

 

 

五、ThreadLocal使用的一般步骤

 

1、在多线程的类（如ThreadDemo类）中，创建一个ThreadLocal对象threadXxx，用来保存线程间需要隔离处理的对象xxx。

2、在ThreadDemo类中，创建一个获取要隔离访问的数据的方法getXxx()，在方法中判断，若ThreadLocal对象为null时候，应该new()一个隔离访问类型的对象，并强制转换为要应用的类型。

3、在ThreadDemo类的run()方法中，通过getXxx()方法获取要操作的数据，这样可以保证每个线程对应一个数据对象，在任何时刻都操作的是这个对象。

文章出自：http://blog.51cto.com/lavasoft/51926，代码为亲自手撕