还在用 SimpleDateFormat 做时间格式化？小心项目崩掉！

本是古典何须时尚 2023-09-26 18:04 36阅读 0赞

*  `SimpleDateFormat.parse()` 方法的线程安全问题
    
     *  错误示例
     *  非线程安全原因分析
     *  解决方法
 *  `SimpleDateFormat.format()` 方法的线程安全问题
    
     *  错误示例
     *  非线程安全原因分析
     *  解决方法

--------------------

`SimpleDateFormat`在多线程环境下存在线程安全问题。

#### 1 SimpleDateFormat.parse() 方法的线程安全问题 ####

1.1 错误示例

错误使用`SimpleDateFormat.parse()`的代码如下:

import java.text.SimpleDateFormat;  
      
    public class SimpleDateFormatTest {  
        private static final SimpleDateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
      
        public static void main(String[] args) {  
      
            /**  
             * SimpleDateFormat线程不安全，没有保证线程安全(没有加锁)的情况下，禁止使用全局SimpleDateFormat,否则报错 NumberFormatException  
             *  
             * private static final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
             */  
            for (int i = 0; i < 20; ++i) {  
                Thread thread = new Thread(() -> {  
                    try {  
                        // 错误写法会导致线程安全问题  
                        System.out.println(Thread.currentThread().getName() + "--" + SIMPLE_DATE_FORMAT.parse("2020-06-01 11:35:00"));  
                    } catch (Exception e) {  
                        e.printStackTrace();  
                    }  
                }, "Thread-" + i);  
                thread.start();  
            }  
        }  
    }

报错：

![215826fd0ff112d9e56b613a0764fc5a.png][]

1.2 非线程安全原因分析

查看源码中可以看到：`SimpleDateFormat`继承`DateFormat`类，`SimpleDateFormat`转换日期是通过继承自`DateFormat`类的`Calendar`对象来操作的，`Calendar`对象会被用来进行日期-时间计算，既被用于`format`方法也被用于`parse`方法。

![1f766a7b0192d1a15ac35cd770773b8f.png][]

`SimpleDateFormat` 的 `parse(String source)` 方法 会调用继承自父类的 `DateFormat` 的 `parse(String source)` 方法

![58960d98d075173dcaf492b1d27319ca.png][]

`DateFormat` 的 `parse(String source)` 方法会调用`SimpleDateFormat`中重写的 `parse(String text, ParsePosition pos)` 方法，该方法中有个地方需要关注

![38f5918d5416f40c5d54ef25a779b63e.png][]

`SimpleDateFormat` 中重写的 `parse(String text, ParsePosition pos)` 方法中调用了 `establish(calendar)` 这个方法：

![06202a7785056ef8250c07d52a8207ee.png][]

该方法中调用了 `Calendar` 的 `clear()` 方法

![3ad68699d86829d509dc0e9d9e5ca244.png][]

可以发现整个过程中`Calendar`对象它并不是线程安全的，如果，a线程将`calendar`清空了，`calendar` 就没有新值了，恰好此时b线程刚好进入到parse方法用到了`calendar`对象，那就会产生[线程安全问题][Link 1]了！

正常情况下：

![9badff6c3de925f1d843f043b00227fd.png][]

非线程安全的流程：

![44dc368a774146cd9c2ddf2c55ed9108.png][]

1.3 解决方法

方法1：每个线程都new一个`SimpleDateFormat`

import java.text.SimpleDateFormat;  
      
    public class SimpleDateFormatTest {  
      
        public static void main(String[] args) {  
            for (int i = 0; i < 20; ++i) {  
                Thread thread = new Thread(() -> {  
                    try {  
                        // 每个线程都new一个  
                        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
                        System.out.println(Thread.currentThread().getName() + "--" + simpleDateFormat.parse("2020-06-01 11:35:00"));  
                    } catch (Exception e) {  
                        e.printStackTrace();  
                    }  
                }, "Thread-" + i);  
                thread.start();  
            }  
        }  
    }

方式2：`synchronized`等方式加锁

public class SimpleDateFormatTest {  
        private static final SimpleDateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
      
        public static void main(String[] args) {  
      
            for (int i = 0; i < 20; ++i) {  
                Thread thread = new Thread(() -> {  
                    try {  
                        synchronized (SIMPLE_DATE_FORMAT) {  
                            System.out.println(Thread.currentThread().getName() + "--" + SIMPLE_DATE_FORMAT.parse("2020-06-01 11:35:00"));  
                        }  
                    } catch (Exception e) {  
                        e.printStackTrace();  
                    }  
                }, "Thread-" + i);  
                thread.start();  
            }  
        }  
    }

方式3：使用`ThreadLocal` 为每个线程创建一个独立变量

import java.text.DateFormat;  
    import java.text.SimpleDateFormat;  
      
    public class SimpleDateFormatTest {  
      
        private static final ThreadLocal<DateFormat> SAFE_SIMPLE_DATE_FORMAT = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));  
      
        public static void main(String[] args) {  
      
            for (int i = 0; i < 20; ++i) {  
                Thread thread = new Thread(() -> {  
                    try {  
                            System.out.println(Thread.currentThread().getName() + "--" + SAFE_SIMPLE_DATE_FORMAT.get().parse("2020-06-01 11:35:00"));  
                    } catch (Exception e) {  
                        e.printStackTrace();  
                    }  
                }, "Thread-" + i);  
                thread.start();  
            }  
        }  
    }

[ThreadLocal][]的详细使用细节见：

> https://blog.csdn.net/QiuHaoqian/article/details/117077792

#### 2 SimpleDateFormat.format() 方法的线程安全问题 ####

2.1 错误示例

import java.text.SimpleDateFormat;  
    import java.util.Date;  
    import java.util.concurrent.LinkedBlockingQueue;  
    import java.util.concurrent.ThreadPoolExecutor;  
    import java.util.concurrent.TimeUnit;  
      
    public class SimpleDateFormatTest {  
        // 时间格式化对象  
        private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");  
      
        public static void main(String[] args) throws InterruptedException {  
            // 创建线程池执行任务  
            ThreadPoolExecutor threadPool = new ThreadPoolExecutor(  
                    10, 10, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000));  
      
            for (int i = 0; i < 1000; i++) {  
                int finalI = i;  
                // 执行任务  
                threadPool.execute(new Runnable() {  
                    @Override  
                    public void run() {  
                        Date date = new Date(finalI * 1000); // 得到时间对象  
                        formatAndPrint(date); // 执行时间格式化  
                    }  
                });  
            }  
            threadPool.shutdown(); // 线程池执行完任务之后关闭  
        }  
      
        /**  
         * 格式化并打印时间  
         */  
        private static void formatAndPrint(Date date) {  
            String result = simpleDateFormat.format(date); // 执行格式化  
            System.out.println("时间：" + result); // 打印最终结果  
        }  
    }

![281ac143ed86ff91e95adbee51056dd5.png][]

从上述结果可以看出，程序的打印结果竟然有重复内容的，正确的情况应该是没有重复的时间才对。

2.2 非线程安全原因分析

为了找到问题所在，查看 `SimpleDateFormat` 中 `format` 方法的源码来排查一下问题，`format` 源码如下：

![c9d2d932317c549db14efa5f59808617.png][]

从上述源码可以看出，在执行 `SimpleDateFormat.format()` 方法时，会使用 `calendar.setTime()` 方法将输入的时间进行转换，那么我们想想一下这样的场景：

*  线程 1 执行了 `calendar.setTime(date)` 方法，将用户输入的时间转换成了后面格式化时所需要的时间；
 *  线程 1 暂停执行，线程 2 得到 CPU 时间片开始执行；
 *  线程 2 执行了 `calendar.setTime(date)` 方法，对时间进行了修改；
 *  线程 2 暂停执行，线程 1 得出 CPU 时间片继续执行，因为线程 1 和线程 2 使用的是同一对象，而时间已经被线程 2 修改了，所以此时当线程 1 继续执行的时候就会出现线程安全的问题了。

正常的情况下，程序的执行是这样的：

![766d3ffcc2f2bc3a9917e837580fd4fc.png][]

非线程安全的执行流程是这样的：

![6d86549d2c264b0898689c988ecfce15.png][]

2.3 解决方法

同样有三种解决方法

**方法1：每个线程都new一个`SimpleDateFormat`**

public class SimpleDateFormatTest {  
         
        public static void main(String[] args) throws InterruptedException {  
            // 创建线程池执行任务  
            ThreadPoolExecutor threadPool = new ThreadPoolExecutor(  
                    10, 10, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000));  
      
            for (int i = 0; i < 1000; i++) {  
                int finalI = i;  
                // 执行任务  
                threadPool.execute(new Runnable() {  
                    @Override  
                    public void run() {  
                        // 得到时间对象  
                        Date date = new Date(finalI * 1000);  
                        // 执行时间格式化  
                        formatAndPrint(date);  
                    }  
                });  
            }  
            // 线程池执行完任务之后关闭  
            threadPool.shutdown();  
        }  
      
        /**  
         * 格式化并打印时间  
         */  
        private static void formatAndPrint(Date date) {  
            String result = new SimpleDateFormat("mm:ss").format(date); // 执行格式化  
            System.out.println("时间：" + result); // 打印最终结果  
        }  
    }

**方式2：`synchronized`等方式加锁**

所有的线程必须排队执行某些业务才行，这样无形中就降低了程序的运行效率了

public class SimpleDateFormatTest {  
        // 时间格式化对象  
        private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");  
      
        public static void main(String[] args) throws InterruptedException {  
            // 创建线程池执行任务  
            ThreadPoolExecutor threadPool = new ThreadPoolExecutor(  
                    10, 10, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000));  
      
            for (int i = 0; i < 1000; i++) {  
                int finalI = i;  
                // 执行任务  
                threadPool.execute(new Runnable() {  
                    @Override  
                    public void run() {  
                        Date date = new Date(finalI * 1000); // 得到时间对象  
                        formatAndPrint(date); // 执行时间格式化  
                    }  
                });  
            }  
            // 线程池执行完任务之后关闭  
            threadPool.shutdown();  
        }  
      
        /**  
         * 格式化并打印时间  
         */  
        private static void formatAndPrint(Date date) {  
            // 执行格式化  
            String result = null;  
            // 加锁  
            synchronized (SimpleDateFormatTest.class) {  
                result = simpleDateFormat.format(date);  
            }  
            // 打印最终结果  
            System.out.println("时间：" + result);  
        }  
    }

**方式3：使用`ThreadLocal` 为每个线程创建一个独立变量**

public class SimpleDateFormatTest {  
        // 创建 ThreadLocal 并设置默认值  
        private static ThreadLocal<SimpleDateFormat> dateFormatThreadLocal =  
                ThreadLocal.withInitial(() -> new SimpleDateFormat("mm:ss"));  
      
        public static void main(String[] args) {  
            // 创建线程池执行任务  
            ThreadPoolExecutor threadPool = new ThreadPoolExecutor(10, 10, 60,  
                    TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000));  
            // 执行任务  
            for (int i = 0; i < 1000; i++) {  
                int finalI = i;  
                // 执行任务  
                threadPool.execute(() -> {  
                    Date date = new Date(finalI * 1000); // 得到时间对象  
                    formatAndPrint(date); // 执行时间格式化  
                });  
            }  
            threadPool.shutdown(); // 线程池执行完任务之后关闭  
        }  
      
        /**  
         * 格式化并打印时间  
         */  
        private static void formatAndPrint(Date date) {  
            String result = dateFormatThreadLocal.get().format(date); // 执行格式化  
            System.out.println("时间：" + result);  // 打印最终结果  
        }  
    }

[215826fd0ff112d9e56b613a0764fc5a.png]: https://img-blog.csdnimg.cn/img_convert/215826fd0ff112d9e56b613a0764fc5a.png
[1f766a7b0192d1a15ac35cd770773b8f.png]: https://img-blog.csdnimg.cn/img_convert/1f766a7b0192d1a15ac35cd770773b8f.png
[58960d98d075173dcaf492b1d27319ca.png]: https://img-blog.csdnimg.cn/img_convert/58960d98d075173dcaf492b1d27319ca.png
[38f5918d5416f40c5d54ef25a779b63e.png]: https://img-blog.csdnimg.cn/img_convert/38f5918d5416f40c5d54ef25a779b63e.png
[06202a7785056ef8250c07d52a8207ee.png]: https://img-blog.csdnimg.cn/img_convert/06202a7785056ef8250c07d52a8207ee.png
[3ad68699d86829d509dc0e9d9e5ca244.png]: https://img-blog.csdnimg.cn/img_convert/3ad68699d86829d509dc0e9d9e5ca244.png
[Link 1]: http://mp.weixin.qq.com/s?__biz=MzI4Njc5NjM1NQ==&mid=2247519338&idx=2&sn=fe49b8988e466c8e1d974e4b305d10ea&chksm=ebd5b346dca23a50b5b1482f75e5cc1c8a499804fd1ec2386a4011df1234cb84749f45b4a5d4&scene=21#wechat_redirect
[9badff6c3de925f1d843f043b00227fd.png]: https://img-blog.csdnimg.cn/img_convert/9badff6c3de925f1d843f043b00227fd.png
[44dc368a774146cd9c2ddf2c55ed9108.png]: https://img-blog.csdnimg.cn/img_convert/44dc368a774146cd9c2ddf2c55ed9108.png
[ThreadLocal]: http://mp.weixin.qq.com/s?__biz=MzI4Njc5NjM1NQ==&mid=2247510859&idx=1&sn=d288f271be40fac33d495abd3995e0e0&chksm=ebd59467dca21d7120e3267e7e088525d312f92fac23270592f5d4d1f8b9f02f038b0037e2c1&scene=21#wechat_redirect
[281ac143ed86ff91e95adbee51056dd5.png]: https://img-blog.csdnimg.cn/img_convert/281ac143ed86ff91e95adbee51056dd5.png
[c9d2d932317c549db14efa5f59808617.png]: https://img-blog.csdnimg.cn/img_convert/c9d2d932317c549db14efa5f59808617.png
[766d3ffcc2f2bc3a9917e837580fd4fc.png]: https://img-blog.csdnimg.cn/img_convert/766d3ffcc2f2bc3a9917e837580fd4fc.png
[6d86549d2c264b0898689c988ecfce15.png]: https://img-blog.csdnimg.cn/img_convert/6d86549d2c264b0898689c988ecfce15.png