还在使用SimpleDateFormat？你的项目崩没？

傷城~ 2021-09-30 22:00 119阅读 0赞

> 文本公众号来源：Felix周(id:felix\_space)  作者：Felix 
> 
>   
> 一篇关于SimpleDateFormat干货分享给大家！

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg]

一 前言

日常开发中，我们经常需要使用时间相关类，说到时间相关类，想必大家对SimpleDateFormat并不陌生。主要是用它进行时间的格式化输出和解析，挺方便快捷的，但是SimpleDateFormat并**不是一个线程安全的类**。在多线程情况下，会出现异常，想必有经验的小伙伴也遇到过。下面我们就来分析分析SimpleDateFormat为什么不安全？是怎么引发的？以及多线程下有那些SimpleDateFormat的解决方案？

先看看**《阿里巴巴开发手册》**对于SimpleDateFormat是怎么看待的：

![640?wx\_fmt=png][640_wx_fmt_png]

公众号后台回复"**手册**"获取**《阿里巴巴开发手册》v 1.4.0 PDF**

二 问题场景复现

一般我们使用SimpleDateFormat的时候会把它定义为一个**静态变量**，避免频繁创建它的对象实例，如下代码：

1.      public class SimpleDateFormatTest {
              class SimpleDateFormatTest {
2.    
    
3.         private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
4.    
    
5.         public static String formatDate(Date date) throws ParseException {
              public static String formatDate(Date date) throws ParseException {
6.             return sdf.format(date);return sdf.format(date);
7.         }
8.    
    
9.         public static Date parse(String strDate) throws ParseException {
              public static Date parse(String strDate) throws ParseException {
10.            return sdf.parse(strDate);return sdf.parse(strDate);
11.        }
12.   
    
13.        public static void main(String[] args) throws InterruptedException, ParseException {
              public static void main(String[] args) throws InterruptedException, ParseException {
14.   
    
15.            System.out.println(sdf.format(new Date()));System.out.println(sdf.format(new Date()));
16.   
    
17.        }
18.     }

是不是感觉没什么毛病？单线程下自然没毛病了，都是运用到多线程下就有大问题了。 测试下：

1.    
    
2.             ExecutorService service = Executors.newFixedThreadPool(100);ExecutorService service = Executors.newFixedThreadPool(100);
3.    
    
4.             for (int i = 0; i < 20; i++) {
              for (int i = 0; i < 20; i++) {
5.                 service.execute(() -> {
6.                     for (int j = 0; j < 10; j++) {
              for (int j = 0; j < 10; j++) {
7.                         try {
              try {
8.                             System.out.println(parse("2018-01-02 09:45:59"));System.out.println(parse("2018-01-02 09:45:59"));
9.                         } catch (ParseException e) {
              catch (ParseException e) {
10.                            e.printStackTrace();
11.                        }
12.                    }
13.                });
14.            }
15.            // 等待上述的线程执行完// 等待上述的线程执行完
16.            service.shutdown();
17.            service.awaitTermination(1, TimeUnit.DAYS);1, TimeUnit.DAYS);
18.        }

`   public static void main(String[] args) throws InterruptedException, ParseException { public static void main(String[] args) throws InterruptedException, ParseException {`

控制台打印结果：

![640?wx\_fmt=png][640_wx_fmt_png 1]

你看这不崩了？部分线程获取的时间不对，部分线程直接报 **java.lang.NumberFormatException:multiple points**错，线程直接挂死了。

三 多线程不安全原因

因为我们把SimpleDateFormat定义为静态变量，那么多线程下SimpleDateFormat的实例就会**被多个线程共享**，B线程会读取到A线程的时间，就会出现时间差异和其它各种问题。SimpleDateFormat和它继承的DateFormat类也不是线程安全的

来看看SimpleDateFormat的format()方法的源码

1.         // Called from Format after creating a FieldDelegate// Called from Format after creating a FieldDelegate
2.         private StringBuffer format(Date date, StringBuffer toAppendTo,private StringBuffer format(Date date, StringBuffer toAppendTo,
3.                                     FieldDelegate delegate) {
              FieldDelegate delegate) {
4.             // Convert input date to time field list// Convert input date to time field list
5.             calendar.setTime(date);
6.    
    
7.             boolean useDateFormatSymbols = useDateFormatSymbols();boolean useDateFormatSymbols = useDateFormatSymbols();
8.    
    
9.             for (int i = 0; i < compiledPattern.length; ) {
              for (int i = 0; i < compiledPattern.length; ) {
10.                int tag = compiledPattern[i] >>> 8;int tag = compiledPattern[i] >>> 8;
11.                int count = compiledPattern[i++] & 0xff;int count = compiledPattern[i++] & 0xff;
12.                if (count == 255) {
              if (count == 255) {
13.                    count = compiledPattern[i++] << 16;16;
14.                    count |= compiledPattern[i++];
15.                }
16.   
    
17.                switch (tag) {
              switch (tag) {
18.                case TAG_QUOTE_ASCII_CHAR:case TAG_QUOTE_ASCII_CHAR:
19.                    toAppendTo.append((char)count);char)count);
20.                    break;break;
21.   
    
22.                case TAG_QUOTE_CHARS:case TAG_QUOTE_CHARS:
23.                    toAppendTo.append(compiledPattern, i, count);
24.                    i += count;
25.                    break;break;
26.   
    
27.                default:default:
28.                    subFormat(tag, count, delegate, toAppendTo, useDateFormatSymbols);
29.                    break;break;
30.                }
31.            }
32.            return toAppendTo;return toAppendTo;
33.        }

注意， calendar.setTime(date)，SimpleDateFormat的format方法实际操作的就是**Calendar**。

因为我们声明SimpleDateFormat为static变量，那么它的**Calendar**变量也就是一个共享变量，**可以被多个线程访问**。

假设线程A执行完calendar.setTime(date)，把时间设置成2019-01-02，这时候被挂起，线程B获得CPU执行权。线程B也执行到了calendar.setTime(date)，把时间设置为2019-01-03。线程挂起，线程A继续走，**calendar**还会被继续使用(subFormat方法)，而这时**calendar**用的是线程B设置的值了，而这就是引发问题的根源，出现时间不对，线程挂死等等。

**其实SimpleDateFormat源码上作者也给过我们提示：**

1.      * Date formats are not synchronized.Date formats are not synchronized.
2.      * It is recommended to create separate format instances for each thread.It is recommended to create separate format instances for each thread.
3.      * If multiple threads access a format concurrently, it must be synchronizedIf multiple threads access a format concurrently, it must be synchronized
4.      * externally.

意思就是

> 日期格式不同步。
> 
>  建议为每个线程创建单独的格式实例。 
> 
> 如果多个线程同时访问一种格式，则必须在外部同步该格式。

四 解决方案

### 只在需要的时候创建新实例，不用static修饰 ###

1.         public static String formatDate(Date date) throws ParseException {
              public static String formatDate(Date date) throws ParseException {
2.             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
3.             return sdf.format(date);return sdf.format(date);
4.         }
5.    
    
6.         public static Date parse(String strDate) throws ParseException {
              public static Date parse(String strDate) throws ParseException {
7.             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
8.             return sdf.parse(strDate);return sdf.parse(strDate);
9.         }

如上代码，仅在需要用到的地方创建一个新的实例，就没有线程安全问题，不过也加重了创建对象的负担，会*频繁地创建和销毁对象，效率较低*。

### synchronized大法好 ###

1.         private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
2.    
    
3.         public static String formatDate(Date date) throws ParseException {
              public static String formatDate(Date date) throws ParseException {
4.             synchronized(sdf){
              synchronized(sdf){
5.                 return sdf.format(date);return sdf.format(date);
6.             }
7.         }
8.    
    
9.         public static Date parse(String strDate) throws ParseException {
              public static Date parse(String strDate) throws ParseException {
10.            synchronized(sdf){
              synchronized(sdf){
11.                return sdf.parse(strDate);return sdf.parse(strDate);
12.            }
13.        }

简单粗暴，synchronized往上一套也可以解决线程安全问题，缺点自然就是*并发量大的时候会对性能有影响，线程阻塞*。

### ThreadLocal ###

1.         private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>() {
              private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>() {
2.             @Override@Override
3.             protected DateFormat initialValue() {
              protected DateFormat initialValue() {
4.                 return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
5.             }
6.         };
7.    
    
8.         public static Date parse(String dateStr) throws ParseException {
              public static Date parse(String dateStr) throws ParseException {
9.             return threadLocal.get().parse(dateStr);return threadLocal.get().parse(dateStr);
10.        }
11.   
    
12.        public static String format(Date date) {
              public static String format(Date date) {
13.            return threadLocal.get().format(date);return threadLocal.get().format(date);
14.        }

ThreadLocal可以确保每个线程都可以得到单独的一个SimpleDateFormat的对象，那么自然也就不存在竞争问题了。

### 基于JDK1.8的DateTimeFormatter ###

也是《阿里巴巴开发手册》给我们的解决方案，对之前的代码进行改造：

1.      public class SimpleDateFormatTest {
              class SimpleDateFormatTest {
2.    
    
3.         private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
4.    
    
5.         public static String formatDate2(LocalDateTime date) {
              public static String formatDate2(LocalDateTime date) {
6.             return formatter.format(date);return formatter.format(date);
7.         }
8.    
    
9.         public static LocalDateTime parse2(String dateNow) {
              public static LocalDateTime parse2(String dateNow) {
10.            return LocalDateTime.parse(dateNow, formatter);return LocalDateTime.parse(dateNow, formatter);
11.        }
12.   
    
13.        public static void main(String[] args) throws InterruptedException, ParseException {
              public static void main(String[] args) throws InterruptedException, ParseException {
14.   
    
15.            ExecutorService service = Executors.newFixedThreadPool(100);ExecutorService service = Executors.newFixedThreadPool(100);
16.   
    
17.            // 20个线程// 20个线程
18.            for (int i = 0; i < 20; i++) {
              for (int i = 0; i < 20; i++) {
19.                service.execute(() -> {
20.                    for (int j = 0; j < 10; j++) {
              for (int j = 0; j < 10; j++) {
21.                        try {
              try {
22.                            System.out.println(parse2(formatDate2(LocalDateTime.now())));System.out.println(parse2(formatDate2(LocalDateTime.now())));
23.                        } catch (Exception e) {
              catch (Exception e) {
24.                            e.printStackTrace();
25.                        }
26.                    }
27.                });
28.            }
29.            // 等待上述的线程执行完// 等待上述的线程执行完
30.            service.shutdown();
31.            service.awaitTermination(1, TimeUnit.DAYS);1, TimeUnit.DAYS);
32.   
    
33.   
    
34.        }
35.     }

*运行结果就不贴了，不会出现报错和时间不准确的问题。*

DateTimeFormatter源码上作者也加注释说明了，**他的类是不可变的，并且是线程安全的。**

1.      * This class is immutable and thread-safe.This class is immutable and thread-safe.

**OK，现在是不是可以对你项目里的日期工具类进行一波优化了呢？**

![640?wx\_fmt=gif][640_wx_fmt_gif]