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<DateFormat> threadLocal = new ThreadLocal<DateFormat>() {
@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
参考：
https://blog.csdn.net/jike11231/article/details/108528406
SimpleDateFormat不安全解决方法有很多种：
1.局部变量
2.加锁synchronized
3.ThreadLocal
4.DateTimeFormatter代替 SimpleDateFormat
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.concurrent.*;
/**
* Created by Administrator on 2022/7/19.
*/
public class ThreadLocalSdf {
private static ThreadLocal<SimpleDateFormat> simpleDateFormatThreadLocal = new ThreadLocal<SimpleDateFormat>() {
@Override protected SimpleDateFormat initialValue() {
return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
}
};
private static ThreadLocal<SimpleDateFormat> simpleDateFormatThreadLocal2 = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
/*** 定义一个 CountDownLatch，保证所有子线程执行完之后主线程再执行 */
private static CountDownLatch countDownLatch = new CountDownLatch(100);
/*** 使用 ThreadFactoryBuilder 定义一个线程池 */
private static ThreadFactory namedThreadFactory = new ThreadFactoryBuilder() .setNameFormat("demo-pool-%d").build();
private static ExecutorService pool = new ThreadPoolExecutor(5, 200, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());
public static void main(String[] args) {
// 3.ThreadLocal饿汉式或懒汉式(延迟加载)。此种为饿汉式。
System.out.println(simpleDateFormatThreadLocal.get().format(new Date()));
System.out.println(simpleDateFormatThreadLocal2.get().format(new Date()));
//定义一个线程安全的 HashSet
Set<String> dates = Collections.synchronizedSet(new HashSet<String>());
for (int i = 0; i < 100; i++) {
//获取当前时间
Calendar calendar = Calendar.getInstance();
int finalI = i;
pool.execute(() -> {
// 1.局部变量
// SimpleDateFormat 声明成局部变量
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:m m:ss");
//时间增加
calendar.add(Calendar.DATE, finalI);
//通过 simpleDateFormat 把时间转换成字符串
// 2.加锁synchronized
// synchronized (simpleDateFormat){
// dateString = simpleDateFormat.format(calendar.getTime());
// }
String dateString = simpleDateFormat.format(calendar.getTime());
//把字符串放入 Set 中
dates.add(dateString);
//countDown
countDownLatch.countDown();
});
}
// 4.DateTimeFormatter 代替 SimpleDateFormat
//解析日期
String dateStr= "2016 年 10 月 25 日";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy 年 MM 月 dd 日");
LocalDate date= LocalDate.parse(dateStr, formatter);
//日期转换为字符串
LocalDateTime now = LocalDateTime.now();
DateTimeFormatter format = DateTimeFormatter.ofPattern("yyyy 年 MM 月 dd 日 hh:mm a");
String nowStr = now .format(format);
System.out.println(nowStr);
}
}
方式1更方便，但是考虑到资源及性能消耗可考虑其他方式。
原创文章，作者：dweifng，如若转载，请注明出处：https://blog.ytso.com/275390.html