java ThreadLocal使用案例详解

本文借由并发环境下使用线程不安全的SimpleDateFormat优化案例,帮助大家理解ThreadLocal.

最近整理公司项目,发现不少写的比较糟糕的地方,比如下面这个:

public class DateUtil {

  private final static SimpleDateFormat sdfyhm = new SimpleDateFormat(
      "yyyyMMdd");

  public synchronized static Date parseymdhms(String source) {
    try {
      return sdfyhm.parse(source);
    } catch (ParseException e) {
      e.printStackTrace();
      return new Date();
    }
  }

}

首先分析下:
该处的函数parseymdhms()使用了synchronized修饰,意味着该操作是线程不安全的,所以需要同步,线程不安全也只能是SimpleDateFormat的parse()方法,查看下源码,在SimpleDateFormat里面有一个全局变量

protected Calendar calendar;

Date parse() {

  calendar.clear();

 ... // 执行一些操作, 设置 calendar 的日期什么的

 calendar.getTime(); // 获取calendar的时间

}

该clear()操作会造成线程不安全.

此外使用synchronized 关键字对性能有很大影响,尤其是多线程的时候,每一次调用parseymdhms方法都会进行同步判断,并且同步本身开销就很大,因此这是不合理的解决方案.

改进方法

线程不安全是源于多线程使用了共享变量造成,所以这里使用ThreadLocal<SimpleDateFormat>来给每个线程单独创建副本变量,先给出代码,再分析这样的解决问题的原因.

/**
 * 日期工具类(使用了ThreadLocal获取SimpleDateFormat,其他方法可以直接拷贝common-lang)
 * @author Niu Li
 * @date 2016/11/19
 */
public class DateUtil {

  private static Map<String,ThreadLocal<SimpleDateFormat>> sdfMap = new HashMap<String, ThreadLocal<SimpleDateFormat>>();

  private static Logger logger = LoggerFactory.getLogger(DateUtil.class);

  public final static String MDHMSS = "MMddHHmmssSSS";
  public final static String YMDHMS = "yyyyMMddHHmmss";
  public final static String YMDHMS_ = "yyyy-MM-dd HH:mm:ss";
  public final static String YMD = "yyyyMMdd";
  public final static String YMD_ = "yyyy-MM-dd";
  public final static String HMS = "HHmmss";

  /**
   * 根据map中的key得到对应线程的sdf实例
   * @param pattern map中的key
   * @return 该实例
   */
  private static SimpleDateFormat getSdf(final String pattern){
    ThreadLocal<SimpleDateFormat> sdfThread = sdfMap.get(pattern);
    if (sdfThread == null){
      //双重检验,防止sdfMap被多次put进去值,和双重锁单例原因是一样的
      synchronized (DateUtil.class){
        sdfThread = sdfMap.get(pattern);
        if (sdfThread == null){
          logger.debug("put new sdf of pattern " + pattern + " to map");
          sdfThread = new ThreadLocal<SimpleDateFormat>(){
            @Override
            protected SimpleDateFormat initialValue() {
              logger.debug("thread: " + Thread.currentThread() + " init pattern: " + pattern);
              return new SimpleDateFormat(pattern);
            }
          };
          sdfMap.put(pattern,sdfThread);
        }
      }
    }
    return sdfThread.get();
  }

  /**
   * 按照指定pattern解析日期
   * @param date 要解析的date
   * @param pattern 指定格式
   * @return 解析后date实例
   */
  public static Date parseDate(String date,String pattern){
    if(date == null) {
      throw new IllegalArgumentException("The date must not be null");
    }
    try {
      return getSdf(pattern).parse(date);
    } catch (ParseException e) {
      e.printStackTrace();
      logger.error("解析的格式不支持:"+pattern);
    }
    return null;
  }
  /**
   * 按照指定pattern格式化日期
   * @param date 要格式化的date
   * @param pattern 指定格式
   * @return 解析后格式
   */
  public static String formatDate(Date date,String pattern){
    if (date == null){
      throw new IllegalArgumentException("The date must not be null");
    }else {
      return getSdf(pattern).format(date);
    }
  }
}

测试

在主线程中执行一个,另外两个在子线程执行,使用的都是同一个pattern

public static void main(String[] args) {
    DateUtil.formatDate(new Date(),MDHMSS);
    new Thread(()->{
      DateUtil.formatDate(new Date(),MDHMSS);
    }).start();
    new Thread(()->{
      DateUtil.formatDate(new Date(),MDHMSS);
    }).start();
  }

日志分析

put new sdf of pattern MMddHHmmssSSS to map
thread: Thread[main,5,main] init pattern: MMddHHmmssSSS
thread: Thread[Thread-0,5,main] init pattern: MMddHHmmssSSS
thread: Thread[Thread-1,5,main] init pattern: MMddHHmmssSSS

分析

可以看出来sdfMap put进去了一次,而SimpleDateFormat被new了三次,因为代码中有三个线程.那么这是为什么呢?

对于每一个线程Thread,其内部有一个ThreadLocal.ThreadLocalMap threadLocals的全局变量引用,ThreadLocal.ThreadLocalMap里面有一个保存该ThreadLocal和对应value,一图胜千言,结构图如下:

那么对于sdfMap的话,结构图就变更了下

1.首先第一次执行DateUtil.formatDate(new Date(),MDHMSS);

//第一次执行DateUtil.formatDate(new Date(),MDHMSS)分析
  private static SimpleDateFormat getSdf(final String pattern){
    ThreadLocal<SimpleDateFormat> sdfThread = sdfMap.get(pattern);
    //得到的sdfThread为null,进入if语句
    if (sdfThread == null){
      synchronized (DateUtil.class){
        sdfThread = sdfMap.get(pattern);
        //sdfThread仍然为null,进入if语句
        if (sdfThread == null){
          //打印日志
          logger.debug("put new sdf of pattern " + pattern + " to map");
          //创建ThreadLocal实例,并覆盖initialValue方法
          sdfThread = new ThreadLocal<SimpleDateFormat>(){
            @Override
            protected SimpleDateFormat initialValue() {
              logger.debug("thread: " + Thread.currentThread() + " init pattern: " + pattern);
              return new SimpleDateFormat(pattern);
            }
          };
          //设置进如sdfMap
          sdfMap.put(pattern,sdfThread);
        }
      }
    }
    return sdfThread.get();
  }

这个时候可能有人会问,这里并没有调用ThreadLocal的set方法,那么值是怎么设置进入的呢?
这就需要看sdfThread.get()的实现:

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
      ThreadLocalMap.Entry e = map.getEntry(this);
      if (e != null) {
        @SuppressWarnings("unchecked")
        T result = (T)e.value;
        return result;
      }
    }
    return setInitialValue();
  }

也就是说当值不存在的时候会调用setInitialValue()方法,该方法会调用initialValue()方法,也就是我们覆盖的方法.

对应日志打印.

put new sdf of pattern MMddHHmmssSSS to map
thread: Thread[main,5,main] init pattern: MMddHHmmssSSS

2.第二次在子线程执行DateUtil.formatDate(new Date(),MDHMSS);

//第二次在子线程执行`DateUtil.formatDate(new Date(),MDHMSS);`
  private static SimpleDateFormat getSdf(final String pattern){
    ThreadLocal<SimpleDateFormat> sdfThread = sdfMap.get(pattern);
    //这里得到的sdfThread不为null,跳过if块
    if (sdfThread == null){
      synchronized (DateUtil.class){
        sdfThread = sdfMap.get(pattern);
        if (sdfThread == null){
          logger.debug("put new sdf of pattern " + pattern + " to map");
          sdfThread = new ThreadLocal<SimpleDateFormat>(){
            @Override
            protected SimpleDateFormat initialValue() {
              logger.debug("thread: " + Thread.currentThread() + " init pattern: " + pattern);
              return new SimpleDateFormat(pattern);
            }
          };
          sdfMap.put(pattern,sdfThread);
        }
      }
    }
    //直接调用sdfThread.get()返回
    return sdfThread.get();
  }

分析sdfThread.get()

//第二次在子线程执行`DateUtil.formatDate(new Date(),MDHMSS);`
  public T get() {
    Thread t = Thread.currentThread();//得到当前子线程
    ThreadLocalMap map = getMap(t);
    //子线程中得到的map为null,跳过if块
    if (map != null) {
      ThreadLocalMap.Entry e = map.getEntry(this);
      if (e != null) {
        @SuppressWarnings("unchecked")
        T result = (T)e.value;
        return result;
      }
    }
    //直接执行初始化,也就是调用我们覆盖的initialValue()方法
    return setInitialValue();
  }

对应日志:

Thread[Thread-1,5,main] init pattern: MMddHHmmssSSS

总结

在什么场景下比较适合使用ThreadLocal?stackoverflow上有人给出了还不错的回答。
When and how should I use a ThreadLocal variable?
One possible (and common) use is when you have some object that is not thread-safe, but you want to avoid synchronizing access to that object (I'm looking at you, SimpleDateFormat). Instead, give each thread its own instance of the object.

参考代码:

https://github.com/nl101531/JavaWEB 下Util-Demo

参考资料:

深入浅出的学习Java ThreadLocal

SimpleDateFormat的线程安全问题与解决方案

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

您可能感兴趣的文章:

  • Java多线程编程之ThreadLocal线程范围内的共享变量
  • 深入解析Java中ThreadLocal线程类的作用和用法
  • java 中ThreadLocal 的正确用法
  • Java 并发编程之ThreadLocal详解及实例
  • 实例详解Java中ThreadLocal内存泄露
  • Java中的线程同步与ThreadLocal无锁化线程封闭实现
  • 实例讲解Java并发编程之ThreadLocal类
  • Java多线程编程中ThreadLocal类的用法及深入
  • Java 中ThreadLocal类详解
  • 简单分析Java线程编程中ThreadLocal类的使用
时间: 2018-03-19

Java多线程编程之ThreadLocal线程范围内的共享变量

模拟ThreadLocal类实现:线程范围内的共享变量,每个线程只能访问他自己的,不能访问别的线程. package com.ljq.test.thread; import java.util.HashMap; import java.util.Map; import java.util.Random; /** * 线程范围内的共享变量 * * 三个模块共享数据,主线程模块和AB模块 * * @author Administrator * */ public class ThreadScopeS

Java中的线程同步与ThreadLocal无锁化线程封闭实现

Synchronized关键字 Java语言的关键字,当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码. 当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行.另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块. 然而,当一个线程访问object的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该object中的非synchronized(

Java 中ThreadLocal类详解

ThreadLocal类,代表一个线程局部变量,通过把数据放在ThreadLocal中,可以让每个线程创建一个该变量的副本.也可以看成是线程同步的另一种方式吧,通过为每个线程创建一个变量的线程本地副本,从而避免并发线程同时读写同一个变量资源时的冲突. 示例如下: import java.util.Random; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import ja

java 中ThreadLocal 的正确用法

java 中ThreadLocal 的正确用法 用法一:在关联数据类中创建private static ThreadLocalThreaLocal的JDK文档中说明:ThreadLocal instances are typically private static fields in classes that wish to associate state with a thread.如果我们希望通过某个类将状态(例如用户ID.事务ID)与线程关联起来,那么通常在这个类中定义private s

简单分析Java线程编程中ThreadLocal类的使用

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

Java 并发编程之ThreadLocal详解及实例

Java 理解 ThreadLocal 摘要: ThreadLocal 又名线程局部变量,是 Java 中一种较为特殊的线程绑定机制,用于保证变量在不同线程间的隔离性,以方便每个线程处理自己的状态.进一步地,本文以ThreadLocal类的源码为切入点,深入分析了ThreadLocal类的作用原理,并给出应用场景和一般使用步骤. 一. 对 ThreadLocal 的理解 1). ThreadLocal 概述 ThreadLocal 又名 线程局部变量,是 Java 中一种较为特殊的 线程绑定机制

实例讲解Java并发编程之ThreadLocal类

ThreadLocal类可以理解为ThreadLocalVariable(线程局部变量),提供了get与set等访问接口或方法,这些方法为每个使用该变量的线程都存有一份独立的副本,因此get总是返回当前执行线程在调用set时设置的最新值.可以将ThreadLocal<T>视为 包含了Map<Thread,T>对象,保存了特定于该线程的值. 概括起来说,对于多线程资源共享的问题,同步机制采用了"以时间换空间"的方式,而ThreadLocal采用了"以空间

Java多线程编程中ThreadLocal类的用法及深入

ThreadLocal,直译为"线程本地"或"本地线程",如果你真的这么认为,那就错了!其实,它就是一个容器,用于存放线程的局部变量,我认为应该叫做 ThreadLocalVariable(线程局部变量)才对,真不理解为什么当初 Sun 公司的工程师这样命名. 早在 JDK 1.2 的时代,java.lang.ThreadLocal 就诞生了,它是为了解决多线程并发问题而设计的,只不过设计得有些难用,所以至今没有得到广泛使用.其实它还是挺有用的,不相信的话,我们一起

深入解析Java中ThreadLocal线程类的作用和用法

ThreadLocal与线程成员变量还有区别,ThreadLocal该类提供了线程局部变量.这个局部变量与一般的成员变量不一样,ThreadLocal的变量在被多个线程使用时候,每个线程只能拿到该变量的一个副本,这是Java API中的描述,通过阅读API源码,发现并非副本,副本什么概念?克隆品? 或者是别的样子,太模糊.   准确的说,应该是ThreadLocal类型的变量内部的注册表(Map<Thread,T>)发生了变化,但ThreadLocal类型的变量本身的确是一个,这才是本质!  

实例详解Java中ThreadLocal内存泄露

案例与分析 问题背景 在 Tomcat 中,下面的代码都在 webapp 内,会导致WebappClassLoader泄漏,无法被回收. public class MyCounter { private int count = 0; public void increment() { count++; } public int getCount() { return count; } } public class MyThreadLocal extends ThreadLocal<MyCount

实例详解Java中如何对方法进行调用

方法调用 Java支持两种调用方法的方式,根据方法是否返回值来选择. 当程序调用一个方法时,程序的控制权交给了被调用的方法.当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序. 当方法返回一个值的时候,方法调用通常被当做一个值.例如: int larger = max(30, 40); 如果方法返回值是void,方法调用一定是一条语句.例如,方法println返回void.下面的调用是个语句: System.out.println("Welcome to Java!")

详解Java 中程序内存的分析

这篇文章将简单的说明下当我们运行Java程序时JVM(Java虚拟机)的内存分配情况. 首先我们先来感观的认识下几个名词: 1.栈,一般来说,基本数据类型直接在栈中分配空间,局部变量(在方法代码段中定义的变量)也在栈中直接分配空间,当局部变量所在方法执行完成之后该空间便立刻被JVM回收,还有一种是引用数据类型,即我们通常所说的需要用关键字new创建出来的对象所对应的引用也是在栈空间中,此时,JVM在栈空间中给对象引用分配了一个地址空间(相当于一个门牌号,通过这个门牌号就可以找到你家),在堆空间中

详解Java中AbstractMap抽象类

jdk1.8.0_144 下载地址:http://www.jb51.net/softs/551512.html AbstractMap抽象类实现了一些简单且通用的方法,本身并不难.但在这个抽象类中有两个方法非常值得关注,keySet和values方法源码的实现可以说是教科书式的典范. 抽象类通常作为一种骨架实现,为各自子类实现公共的方法.上一篇我们讲解了Map接口,此篇对AbstractMap抽象类进行剖析研究. Java中Map类型的数据结构有相当多,AbstractMap作为它们的骨架实现实

详解java 中Spring jsonp 跨域请求的实例

详解java 中Spring jsonp 跨域请求的实例 jsonp介绍 JSONP(JSON with Padding)是JSON的一种"使用模式",可用于解决主流浏览器的跨域数据访问的问题.由于同源策略,一般来说位于 server1.example.com 的网页无法与不是 server1.example.com的服务器沟通,而 HTML 的<script> 元素是一个例外.利用 <script> 元素的这个开放策略,网页可以得到从其他来源动态产生的 JSO

详解java中this.getClass()和super.getClass()的实例

详解java中this.getClass()和super.getClass()的实例 前言: 遇到this.getClass()和super.getClass()的返回值感到疑惑,经过探索豁然开朗. getClass()是java中Object类的一个方法,其原型为: public final Class<?> getClass() 返回值为 当前运行时类的Class对象. 所以写了一段代码来说明: getClass()不受this和super影响,而是有当前的运行类决定的. 代码如下: 父类

详解 Java中日期数据类型的处理之格式转换的实例

详解 Java中日期数据类型的处理之格式转换的实例 概要: 日期以及时间格式处理,在Java中时间格式一般会涉及到的数据类型包括Calendar类和Date类. Date类: 1.Date类型转String类型(以时间格式1970-01-01 01:01:01为例) //yyyy-MM-dd HH:mm:ss表示24时间进制 SimpleDateFormat sDateFormat=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); String

详解Java中的不可变对象

不可变对象想必大部分朋友都不陌生,大家在平时写代码的过程中100%会使用到不可变对象,比如最常见的String对象.包装器对象等,那么到底为何Java语言要这么设计,真正意图和考虑点是什么?可能一些朋友没有细想过这些问题,今天我们就来聊聊跟不可变对象有关的话题. 一.什么是不可变对象 下面是<Effective Java>这本书对于不可变对象的定义: 不可变对象(Immutable Object):对象一旦被创建后,对象所有的状态及属性在其生命周期内不会发生任何变化. 从不可变对象的定义来看,

详解JAVA中static的作用

1.深度总结 引用一位网友的话,说的非常好,如果别人问你static的作用:如果你说静态修饰 类的属性 和 类的方法 别人认为你是合格的:如果是说 可以构成 静态代码块,那别人认为你还可以: 如果你说可以构成 静态内部类, 那别人认为你不错:如果你说了静态导包,那别人认为你很OK: 那我们就先在这几方面一一对static进行总结:然后说一些模糊的地方,以及一些面试中容易问道的地方: 1)static方法 static方法一般称作静态方法,由于静态方法不依赖于任何对象就可以进行访问,因此对于静态方

详解Java中HashSet和TreeSet的区别

详解Java中HashSet和TreeSet的区别 1. HashSet HashSet有以下特点: 不能保证元素的排列顺序,顺序有可能发生变化 不是同步的 集合元素可以是null,但只能放入一个null 当向HashSet集合中存入一个元素时,HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值,然后根据 hashCode值来决定该对象在HashSet中存储位置. 简单的说,HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等,并且两个