JavaSe：ThreadLocal

JDK中有一个ThreadLocal类，使用很方便，但是却很容易出现问题。究其原因， 就是对ThreadLocal理解不到位。最近项目中，出现了内存泄漏的问题。其中就有同事在使用ThreadLocal时，没有用好。所以特写下此文。

  • ThreadLocal的设计
  • ThreadLocalMap、ThreadLocal说明
  • 使用ThreadLocal后的内存模型
  • 如何正确的使用ThreadLocal
  • 错误的使用ThreadLocal会造成内存泄漏

ThreadLocal设计

ThreadLocal的类图：

·每个Thread都有一个自己的ThreadLocalMap，默认是null。当线程运行过程中，首次使用某个ThreadLocal对象时，会初始化这个ThreadLocalMap。

·ThreadLocalMap中包括一个Entry数组。我们在程序中是不能直接使用ThreadLocalMap的。在每次使用ThreadLocal时(set,get,remove)，都会自动的使用ThreadLocalMap，进行一定的清理工作。参见方法expungeStaleEntry。

·Entry继承了WeakReference，Key是ThreadLocal对象，Value时目标对象。并且key是被Weak Reference的。所以如果一个ThreadLocal对象TL1被GC后，也就是key是null。

·每个ThreadLocal对象都有一个initValue。在继承ThreadLocal类时，可以对它的initialValue()进行重写。ThreadLocal对外提供了3个常用方法：get,set,remove。

此外，当线程被kill(通过interrupe，或者线程自然结束)时，ThreadLocalMap会被设置为null,那么Map中的各个变量也会被回收（如果不被其它变量引用的话）。

ThreadLocalMap、ThreadLocal说明

ThreadLocalMap

ThreadLocalMap中的expungeStaleEntry(int)方法的可能被调用的处理有：

通过这个图，不难看出这个方法在ThreadLocal的set,get,remove时都会被调用。

从该方法代码中，可以看出是先清理指定的Entry，再遍历，如果发现有Entry的key是null，清理之。Key =null，也就是ThreadLocal对象是null。所以当程序中，将ThreadLocal对象设置为null,在该线程继续执行时，如果执行另一个ThreadLocal时，就会触发该方法。就有可能清理掉key是null的那个ThreadLocal对应的值。

ThreadLocal方法说明：

set() 将目标对象作为当前线程的局部变量的值设置。也就是说，变量名是ThreadLocal对象，变量值是目标对象。

get()，从当前对象中取出ThreadLocal变量的值。如果map中不并在该ThreadLocal变量，就会自动调用initialValue方法。并将该值设置到map中。

remove()，从当前线程中移除ThreadLocal变量的值。此时key,value都不存在map中。

使用ThreadLocal后的内存模型

假设程序中指定2个ThreadLocal的变量TL1、TL2，并且他们都是static时。

private static ThreadLocal<ClassB> TL1 =  new ThreadLocal<ClassB>();
private static ThreadLocal<ClassA> TL2 =  new ThreadLocal<ClassA>();

在运行时有2个线程，每个线程中都设置了这两个线程局部变量TL1,TL2。那么内存模型将是这样的：

在线程Thread1执行过程中，如果执行顺序是这样的：

TL1.set(ObjB1);  //将TL1作为变量名，OBjB1作为变量值设置到Thread1中。
TL1.get();        //从当前线程Thread1中取出变量TL1的值。它的值应该是OBjB1
TL2.set(ObjA1);  //将TL2作为变量名，OBjA1作为变量值设置到Thread1中。
TL2.get();        //从当前线程Thread1中取出变量TL1的值。它的值应该是OBjA1

当执行remove时，应会将该值从ThreadLocalMap中移出。

如何正确使用ThreadLocal呢?

在说如何正确使用之前，先来看一个例子：

package com.fjn.jdk.thread_concurrent.threadlocal;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import org.junit.Test;

public class ThreadLocalTest {

    @Test
    public void testUsingThreadPool() {
        ExecutorService executor = Executors.newCachedThreadPool();
        int workerThreadNumber =10;
        CountDownLatch countDowner = new CountDownLatch(workerThreadNumber);
        for (int i = 0; i < workerThreadNumber; i++) {
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                // clear interrupted flag
                Thread.interrupted();
            }
            executor.submit(new Task(countDowner));
        }

        try {
            countDowner.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executor.shutdownNow();
    }
}

class NamedThreadLocal<T> extends ThreadLocal<T> {
    private String name;

    public NamedThreadLocal(String name) {
        this.name = name;
    }

    public String toString() {
        return "The thread local [" + name + "] is " + this.get();
    }
}

class BusService {
    private CooperationService cooperateService = CooperationService.getService();

    public void doService(String str) {

        try {
            cooperateService.recordStartTime();
            Thread.sleep(500);
            doSomething(str);
            Thread.sleep(500);
        } catch (InterruptedException ex) {
            Thread.currentThread().interrupt();
        } finally {
            cooperateService.clear();
// 此时ThreadLocalMap中已不存在该变量。
        }

        // 正常情况下是不能要这一行代码的：
        // 因为这样做又会重新在ThreadLocalMap中添加一个ThreadLocal变量，并设置值为initailValue
        System.out.println(cooperateService.getStartTime());
    }

    private void doSomething(String str) {
        System.out.println(" do something beging ...");
        System.out.println("start time is : " + cooperateService.getStartTime());
        System.out.println(str);
        System.out.println(" do something end ...");
    }
}

class CooperationService {
    private static CooperationService ins = new CooperationService();
    private static ThreadLocal<Long> threadLocal = new NamedThreadLocal<Long>("Test") {
        protected Long initialValue() {
            return -1l;
        };
    };

    private CooperationService(){

    }

    public static CooperationService getService(){
        return ins;
    } 

    public void recordStartTime() {
        long now = System.currentTimeMillis();
        System.out.println("record start time : " + now);
        threadLocal.set(now);
    }

    public Long getStartTime() {
        return threadLocal.get();
    }

    public void clear() {
        threadLocal.remove();
    }
}

class Task implements Runnable {
    private final CountDownLatch countDownLatch;

    public Task(CountDownLatch countDowner) {
        this.countDownLatch = countDowner;
    }

    @Override
    public void run() {
        BusService service = new BusService();
        service.doService("hello");
        if (countDownLatch != null) {
            countDownLatch.countDown();
        }
    }

}

上面的例子中，使用线程池执行一个Task。Task的内容是调用相关的业务服务，在业务处理过程中，会先记录下业务处理的开始时间，处理过程中可能会使用到这个开始时间，譬如说要将开始处理时间记录到DataBase中。在用完之后，线程要完成任务之前，调用remove将该变量从线程中移出。

在调用ThreadLocal方法get,set,remove时，正确的姿势应该是：

TL1.set(obj);

Try{
     // . . .
     TL1.get();
     // . . .
}
Finally{
     TL1.remove();
}

那么ThreaLocal变量该如何声明呢？

要分为下面几个使用场景了：

1）如果ThreadLocal可以完全在一个方法中使用，不会到另一个方法中使用该ThreadLocal对象。对于这种情况：ThreadLocal完全可以作为该方法的局部变量。例如：

Class Hello {

     public void hello  () {
          // . . .
          ThreadLocal<Long> tl  = new ThreadLocal<Long>();
          tl.set(obj);
          // . . .
          tl.remove();
     }

}

但这种情况毕竟是少数，因为在这种情况下，完全可以不用ThreadLocal的。

2）如果ThreadLocal是在同一个类中的不同方法中使用，可以将ThreadLocal作为该类的字段。

public class Hello {
[static] ThreadLocal<Long> tl = new ThreadLocal<Long>();

public void method1(){
      //  . . .
      tl1.set();
      // . . .

method2();
}

private void method2(){
     tl.get();
   // . . .
    tl.remove();
}
}

这种情况用的相对来说，会多一些。在这种情况下，通常建议的做法是将ThreadLocal声明为static的，但也不是必须的。

3）ThreadLocal要跨类使用，一种方案是将ThreadLocal设置为public static的。另一种方案是像上面的例子一样。

错误使用ThreadLocal造成内存泄漏

实际使用过程中，大家很少会去使用ThreadLocal.remove()方法。另外，还有人会用ThreadLocal来做cache，那就更不可能去使用remove方法了。

前面提到，当线程结束时，ThreadLocalMap也会被自动清理，ThreadLocalMap中的对象如果没有其它的引用，就会被GC掉，这样就不会发生内存泄漏了。

如果线程A没有结束，某个ThreadLocalA对象如果被设置为null，线程A再次执行时，如果还使用到其它的ThreadLocalB。ThreadLocalA关联到的对象也会从ThreadLocalMap中移出。这样也可以避免内存泄漏。

如果线程A没有结束，某个ThreadLocalA对象如果被设置为null，线程A再次使用时，如果是执行的其它的任务，没有使用到任何的ThreadLocal，那么就会造成内存泄漏。

在使用ThreadLocal时，理解它很重要，更要知道怎么用它。

时间： 2024-10-05 15:49:08

JavaSe：ThreadLocal的相关文章

并发编程（四）：ThreadLocal从源码分析总结到内存泄漏

一.目录 1.ThreadLocal是什么?有什么用? 2.ThreadLocal源码简要总结? 3.ThreadLocal为什么会导致内存泄漏? 二.ThreadLocal是什么?有什么用? 引入话题:在并发条件下,如何正确获得共享数据?举例:假设有多个用户需要获取用户信息,一个线程对应一个用户.在mybatis中,session用于操作数据库,那么设置.获取操作分别是session.set().session.get(),如何保证每个线程都能正确操作达到想要的结果? /** * 回顾sync

Java多线程10：ThreadLocal的作用及使用

ThreadLocal的作用 从上一篇对于ThreadLocal的分析来看,可以得出结论:ThreadLocal不是用来解决共享对象的多线程访问问题的,通过ThreadLocal的set()方法设置到线程的ThreadLocal.ThreadLocalMap里的是是线程自己要存储的对象,其他线程不需要去访问,也是访问不到的.各个线程中的ThreadLocal.ThreadLocalMap以及ThreadLocal.ThreadLocal中的值都是不同的对象. 至于为什么要使用ThreadLoca

多线程之：ThreadLocal

Java中ThreadLocal类可以使创建的变量只被同一个线程进行读和写操作,即使有多个线程同时执行同一段代码,并且这段代码中又有一个指向同一个ThreadLocal变量的引用,这些线程依然不能看到彼此ThreadLocal变量域,只能看到自己私有的ThreadLocal实例. 看看如下demo: 1 public class MyThreadLocal { 2 public static class IntegerRandom implements Runnable { 3 private

java多线程18： ThreadLocal的作用

从上一篇对于ThreadLocal的分析来看,可以得出结论:ThreadLocal不是用来解决共享对象的多线程访问问题的,通过ThreadLocal的set()方法设置到线程的ThreadLocal.ThreadLocalMap里的是是线程自己要存储的对象,其他线程不需要去访问,也是访问不到的.各个线程中的ThreadLocal.ThreadLocalMap以及ThreadLocal.ThreadLocal中的值都是不同的对象. 至于为什么要使用ThreadLocal,不妨这么考虑这个问题.Ja

并发组件之一：ThreadLocal线程本地变量

一.简介  ThreadLocal从字面上进行理解很容易被大部分人认为是本地线程,然而ThreadLocal并不是一个Thread,可以说它只是一个容器,而它装的内容又是Thread的局部变量.很多文章都会把ThreadLocal当作是解决高并发下线程不安全的一种做法,然而ThreadLocal并不是为了解决并发安全甚至可以这么说,它与真正的并发安全背道而驰.并发安全是指多个线程对同一个对象进行操作而导致的不安全,但是ThreadLocal在每个线程内部保存了一份该对象,使得每个线程都操作自己内

Android进阶你必须要了解的知识：ThreadLocal

1.ThreadLocal是什么? ThreadLocal是一个线程内部数据存储类,通过他可以在指定的线程中存储数据.存储后,只能在指定的线程中获取到存储的数据,对其他线程来说无法获取到数据. 2.ThreadLocal的使用场景 日常使用场景不多,当某些数据是以线程为作用域并且不同线程具有不同的数据副本的时候,可以考虑使用ThreadLocal.Android源码的Lopper.ActivityThread以及AMS中都用到了ThreadLocal. 3.ThreadLocal的使用示例 pu

并发编程（7）：ThreadLocal

概念 线程局部变量,是一种多线程间并发访问变量的解决方案.与其synchonized等加锁的方式不同,ThreadLocal完全不提供锁,而使用以空间换时间的手段,为每个线程提供变量的独立副本,以保障线程安全. 从性能上说,ThreadLocal不具有绝对的优势,在并发不是很高的时候,加锁的性能会更好,但作为一套与锁完全无关的线程安全解决方案,在高并发量或竞争激烈的场景,使用ThreadLocal可以在一定程度上减少锁竞争. 代码 public class Demo1 { public stat

线程的私家小院儿：ThreadLocal

转载自simplemain老王的公众号 话说在<操作系统原理>这门课里面,我们学到了很多概念:进程.线程.锁.PV操作.读写者问题等等,其中关于进程.线程和锁的东西是我们平时工作中用到最多的:服务器接收到用户请求,需要用一个进程或者一个线程去处理,然后操作内存.文件或者数据库的时候,可能需要对他们进行加锁操作. 不过作为一个有追求的程序员,我们有些时候会不满足于此 .于是,我们开始对线程.锁开始了漫漫的优化之路.其中有一种情况是非常值得优化的:假定我们现在有一个web服务,我们的程序一般都会为

Java多线程9：ThreadLocal源码剖析

http://www.cnblogs.com/xrq730/p/4854813.html ThreadLocal其实比较简单,因为类里就三个public方法:set(T value).get().remove().先剖析源码清楚地知道ThreadLocal是干什么用的.再使用.最后总结,讲解ThreadLocal采取这样的思路. 三个理论基础 在剖析ThreadLocal源码前,先讲一下ThreadLocal的三个理论基础: 1.每个线程都有一个自己的ThreadLocal.ThreadLoca