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

左手的ㄟ右手 2023-10-01 22:20 5阅读 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();
            }
        }
    }

报错：

![7580292e0d949e1b49e5ad77be843fc9.png][]

## 1.2 非线程安全原因分析 ##

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

![88f72d69da5542eab470072171a32dd4.png][]

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

![d930eb7c2866e59adf9116bcb4a7e511.png][]

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

![a0f518b1225181eca1b0ff8815316bdd.png][]

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

![714b1236940b011ff881cc1823df4724.png][]

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

![cf54b908cf9b59281535031cce27967e.png][]

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

正常情况下：

![4630bdc4a445354726a2f3b4fc52bd7e.png][]

非线程安全的流程：

![d4767cf7b94fdd83ccf417d600b2e6ce.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); // 打印最终结果
        }
    }

![5fcb1130cfcca35beb0f36b491cb5b1a.png][]

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

## 2.2 非线程安全原因分析 ##

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

![4491e3132e72f744832232d9ef4c936b.png][]

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

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

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

![5b218d5f3a2bfd6499263aa7a988ddd7.png][]

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

![e3940d2ed1061d27277931ea6134f596.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);  // 打印最终结果
        }
    }

![ba025446a242446598a4a9b55e253fcb.jpeg][]

[7580292e0d949e1b49e5ad77be843fc9.png]: https://img-blog.csdnimg.cn/img_convert/7580292e0d949e1b49e5ad77be843fc9.png
[88f72d69da5542eab470072171a32dd4.png]: https://img-blog.csdnimg.cn/img_convert/88f72d69da5542eab470072171a32dd4.png
[d930eb7c2866e59adf9116bcb4a7e511.png]: https://img-blog.csdnimg.cn/img_convert/d930eb7c2866e59adf9116bcb4a7e511.png
[a0f518b1225181eca1b0ff8815316bdd.png]: https://img-blog.csdnimg.cn/img_convert/a0f518b1225181eca1b0ff8815316bdd.png
[714b1236940b011ff881cc1823df4724.png]: https://img-blog.csdnimg.cn/img_convert/714b1236940b011ff881cc1823df4724.png
[cf54b908cf9b59281535031cce27967e.png]: https://img-blog.csdnimg.cn/img_convert/cf54b908cf9b59281535031cce27967e.png
[4630bdc4a445354726a2f3b4fc52bd7e.png]: https://img-blog.csdnimg.cn/img_convert/4630bdc4a445354726a2f3b4fc52bd7e.png
[d4767cf7b94fdd83ccf417d600b2e6ce.png]: https://img-blog.csdnimg.cn/img_convert/d4767cf7b94fdd83ccf417d600b2e6ce.png
[5fcb1130cfcca35beb0f36b491cb5b1a.png]: https://img-blog.csdnimg.cn/img_convert/5fcb1130cfcca35beb0f36b491cb5b1a.png
[4491e3132e72f744832232d9ef4c936b.png]: https://img-blog.csdnimg.cn/img_convert/4491e3132e72f744832232d9ef4c936b.png
[5b218d5f3a2bfd6499263aa7a988ddd7.png]: https://img-blog.csdnimg.cn/img_convert/5b218d5f3a2bfd6499263aa7a988ddd7.png
[e3940d2ed1061d27277931ea6134f596.png]: https://img-blog.csdnimg.cn/img_convert/e3940d2ed1061d27277931ea6134f596.png
[ba025446a242446598a4a9b55e253fcb.jpeg]: https://img-blog.csdnimg.cn/ba025446a242446598a4a9b55e253fcb.jpeg