ThreadLocal解决SimpleDateFormat线程安全问题

ThreadLocal的应用场景之一就是可以解决SimpleDateFormat线程安全问题。如果是jdk是8及以上的，直接使用java.time下的LocalDateTime即可。

一、SimpleDateFormat线程不安全原因

1：原因解释
SimpleDateFormat(下面简称sdf)类内部有一个Calendar对象引用，它用来储存和这个sdf相关的日期信息，例如sdf.parse(dateStr)， sdf.format(date)诸如此类的方法参数传入的日期相关String，Date等等，都是交给Calendar引用来储存的。

这样就会导致一个问题，如果你的sdf是个static的，那么多个thread 之间就会共享这个sdf，同时也是共享这个Calendar引用，并且，观察sdf.parse()方法，你会发现有如下的调用：

Date parse() {
     
  calendar.clear(); // 清理calendar
  ... // 执行一些操作, 设置 calendar 的日期什么的
  calendar.getTime(); // 获取calendar的时间
}

这里会导致的问题就是，如果线程A调用了sdf.parse()，并且进行了calendar.clear()后还未执行calendar.getTime()的时候，线程B又调用了sdf.parse()，这时候线程B也执行了sdf.clear()方法，这样就导致线程 A 的的calendar数据被清空了(实际上A，B的同时被清空了)。

又或者当 A 执行了calendar.clear()后被挂起，这时候 B 开始调用sdf.parse()并顺利结束，这样 A 的 calendar内存储的的date 变成了后来 B 设置的calendar的date。
2：问题重现
创建普通DateUtil.java工具类

package com.test;

import java.text.SimpleDateFormat;
import java.util.Date;

public class DateUtil {
     
    private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 
    public static  String formatDate(Date date)throws Exception {
     
        return sdf.format(date);
    }
 
    public static Date parse(String strDate) throws Exception{
     
 
        return sdf.parse(strDate);
    }
}

创建DateUtilTest.java，模拟高并发的场景，执行调用DateUtil.java的parse方法

package com.test;

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

public class DateUtilTest {
     
	public static void main(String[] args) {
     
		ExecutorService executorService  = Executors.newFixedThreadPool(5);
	    for( int i = 0;i<9;i++ ){
     
	        executorService.execute( () -> {
     
	            try {
     
	                System.out.println(DateUtil.parse("2020-09-11 16:35:20"));
	            } catch (Exception e) {
     
	                e.printStackTrace();
	            }
	        });
	    }
	}

}

直接报错，截图如下

二、解决方案

方案1：
把static去掉，这样每个新的线程都会创建一个自己的sdf实例，从而避免线程安全的问题。然而，使用这种方法，在高并发的情况下会大量的new sdf以及销毁sdf，这样是非常耗费资源的，所以是不可行的。

方案2：
使用Threadlocal解决，对于每个线程SimpleDateFormat不存在影响他们之间协作的状态，为每个线程创建一个SimpleDateFormat变量的拷贝或者叫做副本，即每个线程会实例化一个SimpleDateFormat实例，实例在线程内共享，达到了解决线程安全性的问题，一定程度上也提高了性能。

代码如下：
ThreadLocalDateUtil.java

**get()**方法是用来获取ThreadLocal在当前线程中保存的变量副本；
**set()**用来设置当前线程中变量的副本；
**remove()**用来移除当前线程中变量的副本；
**initialValue()**方法修改初始值；

package com.test;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 考虑到SimpleDateFormat为线程不安全对象，故应用ThreadLocal来解决，使SimpleDateFormat从独享变量变成单个线程变量
* 
 * 使用ThreadLocal以空间换时间解决SimpleDateFormat线程安全问题。
*/
public class ThreadLocalDateUtil {
     

    //方式1：
    /*private static ThreadLocal threadLocal = new ThreadLocal() {
        @Override
        protected DateFormat initialValue() {
            return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        }
    };

    public static Date parse(String dateStr) throws ParseException {
        return threadLocal.get().parse(dateStr);
    }

    public static String format(Date date) {
        return threadLocal.get().format(date);
    }*/


    //方式2：最终结果：每个线程会实例化一个SimpleDateFormat实例，实例在线程内共享，达到了解决线程安全性的问题，一定程度上也提高了性能。
    private static final String date_format = "yyyy-MM-dd HH:mm:ss";
    private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>();
    //第一次调用get将返回null 
    //获取线程的变量副本，如果不覆盖initialValue，第一次get返回null，故需要初始化一个SimpleDateFormat，并set到threadLocal中  
    public static DateFormat getDateFormat() {
     
        DateFormat df = threadLocal.get();
        if(df == null){
     
            df = new SimpleDateFormat(date_format);
            threadLocal.set(df);
        }
        return df;
    }

    public static String formatDate(Date date) throws ParseException {
     
        return getDateFormat().format(date);
    }

    public static Date parse(String strDate) throws ParseException {
     
        return getDateFormat().parse(strDate);
    }

}

ThreadLocalDateUtilTest.java

package com.test;

import java.text.ParseException;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadLocalDateUtilTest1 {
     
    public static void main(String[] args) {
     
    	  //模拟创建多线程方式1
    	  /*
    	  for (int i = 0; i < 10; i++) {
	            new Thread(new Runnable() {
	                @Override
	                public void run() {
	                	try {
							System.out.println(ThreadLocalDateUtil1.formatDate(new Date()));
							//System.out.println(ThreadLocalDateUtil1.parse("2020-09-11 19:10:20"));
						} catch (ParseException e) {
							e.printStackTrace();
						}
	                }
	            }).start();
	        }
    	*/
    	
    	//模拟创建多线程方式2
    	ExecutorService executorService  = Executors.newFixedThreadPool(5);
	    for( int i = 0;i<9;i++ ){
     
	        executorService.execute( () -> {
     
	            try {
     
	                System.out.println(ThreadLocalDateUtil1.parse("2020-09-11 19:10:20"));
	            } catch (Exception e) {
     
	                e.printStackTrace();
	            }
	        });
	    }
	}
}

ThreadLocalDateUtil.formatDate(new Date())执行结果如下：
ThreadLocalDateUtil.parse(“2020-09-11 19:10:20”)执行结果如下：

参考文章
https://www.jianshu.com/p/f51703b5b0d2
https://blog.csdn.net/qq_35190492/article/details/107599875
https://www.cnblogs.com/chaiming520/p/11089943.html
https://www.cnblogs.com/coderdxj/p/11490773.html