SimpleDateFormat线程不安全的5种解决方案！

￡神魔★判官ぃ 2023-10-04 02:17 17阅读 0赞

![783e761ce3561820840361d75770d367.png][]

作者 | 王磊

来源 | Java中文社群（ID：javacn666）

转载请联系授权（微信ID：GG\_Stone）

### 1.什么是线程不安全？ ###

线程不安全也叫非线程安全，是指**多线程执行中，程序的执行结果和预期的结果不符的情况就叫着线程不安全**。

#### 线程不安全的代码 ####

`SimpleDateFormat` 就是一个典型的线程不安全事例，接下来我们动手来实现一下。首先我们先创建 10 个线程来格式化时间，时间格式化每次传递的待格式化时间都是不同的，所以程序如果正确执行将会打印 10 个不同的值，接下来我们来看具体的代码实现：

import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class SimpleDateFormatExample {
        // 创建 SimpleDateFormat 对象
        private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");
    
        public static void main(String[] args) {
            // 创建线程池
            ExecutorService threadPool = Executors.newFixedThreadPool(10);
            // 执行 10 次时间格式化
            for (int i = 0; i < 10; i++) {
                int finalI = i;
                // 线程池执行任务
                threadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        // 创建时间对象
                        Date date = new Date(finalI * 1000);
                        // 执行时间格式化并打印结果
                        System.out.println(simpleDateFormat.format(date));
                    }
                });
            }
        }
    }

我们预期的正确结果是这样的（10 次打印的值都不同）：

![04ba307bbfca8c00b2368b50c1d12f35.png][]

然而，以上程序的运行结果却是这样的：

![fa73b745db7fedec1f769893b36cf451.png][]

从上述结果可以看出，当在多线程中使用 `SimpleDateFormat` 进行时间格式化是线程不安全的。

### 2.解决方案 ###

**`SimpleDateFormat` 线程不安全的解决方案总共包含以下 5 种：**

1.  **将 `SimpleDateFormat` 定义为局部变量；**
2.  **使用 `synchronized` 加锁执行；**
3.  **使用 `Lock` 加锁执行（和解决方案 2 类似）；**
4.  **使用 `ThreadLocal`；**
5.  **使用 `JDK 8` 中提供的 `DateTimeFormat`。**

接下来我们分别来看每种解决方案的具体实现。

#### ① SimpleDateFormat改为局部变量 ####

将 `SimpleDateFormat` 定义为局部变量时，因为每个线程都是独享 `SimpleDateFormat` 对象的，相当于将多线程程序变成“单线程”程序了，所以不会有线程不安全的问题，具体实现代码如下：

import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class SimpleDateFormatExample {
        public static void main(String[] args) {
            // 创建线程池
            ExecutorService threadPool = Executors.newFixedThreadPool(10);
            // 执行 10 次时间格式化
            for (int i = 0; i < 10; i++) {
                int finalI = i;
                // 线程池执行任务
                threadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        // 创建 SimpleDateFormat 对象
                        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");
                        // 创建时间对象
                        Date date = new Date(finalI * 1000);
                        // 执行时间格式化并打印结果
                        System.out.println(simpleDateFormat.format(date));
                    }
                });
            }
            // 任务执行完之后关闭线程池
            threadPool.shutdown();
        }
    }

以上程序的执行结果为：

![df41dcdc4ee8f0952942791634aa4793.png][]

当打印的结果都不相同时，表示程序的执行是正确的，从上述结果可以看出，将 `SimpleDateFormat` 定义为局部变量之后，就可以成功的解决线程不安全问题了。

#### ② 使用synchronized加锁 ####

锁是解决线程不安全问题最常用的手段，接下来我们先用 `synchronized` 来加锁进行时间格式化，实现代码如下：

import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class SimpleDateFormatExample2 {
        // 创建 SimpleDateFormat 对象
        private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");
    
        public static void main(String[] args) {
            // 创建线程池
            ExecutorService threadPool = Executors.newFixedThreadPool(10);
            // 执行 10 次时间格式化
            for (int i = 0; i < 10; i++) {
                int finalI = i;
                // 线程池执行任务
                threadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        // 创建时间对象
                        Date date = new Date(finalI * 1000);
                        // 定义格式化的结果
                        String result = null;
                        synchronized (simpleDateFormat) {
                            // 时间格式化
                            result = simpleDateFormat.format(date);
                        }
                        // 打印结果
                        System.out.println(result);
                    }
                });
            }
            // 任务执行完之后关闭线程池
            threadPool.shutdown();
        }
    }

以上程序的执行结果为：

![a2acce0e2714b9c5a24f2ccbe10edfcd.png][]

#### ③ 使用Lock加锁 ####

在 Java 语言中，锁的常用实现方式有两种，除了 `synchronized` 之外，还可以使用手动锁 `Lock`，接下来我们使用 `Lock` 来对线程不安全的代码进行改造，实现代码如下：

import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * Lock 解决线程不安全问题
     */
    public class SimpleDateFormatExample3 {
        // 创建 SimpleDateFormat 对象
        private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");
    
        public static void main(String[] args) {
            // 创建线程池
            ExecutorService threadPool = Executors.newFixedThreadPool(10);
            // 创建 Lock 锁
            Lock lock = new ReentrantLock();
            // 执行 10 次时间格式化
            for (int i = 0; i < 10; i++) {
                int finalI = i;
                // 线程池执行任务
                threadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        // 创建时间对象
                        Date date = new Date(finalI * 1000);
                        // 定义格式化的结果
                        String result = null;
                        // 加锁
                        lock.lock();
                        try {
                            // 时间格式化
                            result = simpleDateFormat.format(date);
                        } finally {
                            // 释放锁
                            lock.unlock();
                        }
                        // 打印结果
                        System.out.println(result);
                    }
                });
            }
            // 任务执行完之后关闭线程池
            threadPool.shutdown();
        }
    }

以上程序的执行结果为：

![e87685c151e9049f556ff3e38147644a.png][]

从上述代码可以看出，手动锁的写法相比于 `synchronized` 要繁琐一些。

#### ④ 使用ThreadLocal ####

加锁方案虽然可以正确的解决线程不安全的问题，但同时也引入了新的问题，加锁会让程序进入排队执行的流程，从而一定程度的降低了程序的执行效率，如下图所示：

![a4048dc86113a72a375e0f682fe684a6.png][]那有没有一种方案既能解决线程不安全的问题，同时还可以避免排队执行呢？

答案是有的，可以考虑使用 `ThreadLocal`。`ThreadLocal` 翻译为中文是线程本地变量的意思，字如其人 `ThreadLocal` 就是用来创建线程的私有（本地）变量的，每个线程拥有自己的私有对象，这样就可以避免线程不安全的问题了，实现如下：

![ed9b004daa03403c06af3891281426bb.png][]

知道了实现方案之后，接下来我们使用具体的代码来演示一下 `ThreadLocal` 的使用，实现代码如下：

import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /**
     * ThreadLocal 解决线程不安全问题
     */
    public class SimpleDateFormatExample4 {
        // 创建 ThreadLocal 对象，并设置默认值（new SimpleDateFormat）
        private static ThreadLocal<SimpleDateFormat> threadLocal =
                ThreadLocal.withInitial(() -> new SimpleDateFormat("mm:ss"));
    
        public static void main(String[] args) {
            // 创建线程池
            ExecutorService threadPool = Executors.newFixedThreadPool(10);
            // 执行 10 次时间格式化
            for (int i = 0; i < 10; i++) {
                int finalI = i;
                // 线程池执行任务
                threadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        // 创建时间对象
                        Date date = new Date(finalI * 1000);
                        // 格式化时间
                        String result = threadLocal.get().format(date);
                        // 打印结果
                        System.out.println(result);
                    }
                });
            }
            // 任务执行完之后关闭线程池
            threadPool.shutdown();
        }
    }

以上程序的执行结果为：

![4443058083b06e46feb145beea2f57e5.png][]

##### ThreadLocal和局部变量的区别 #####

首先来说 `ThreadLocal` 不等于局部变量，这里的“局部变量”指的是像 2.1 示例代码中的局部变量， `ThreadLocal` 和局部变量最大的区别在于：`ThreadLocal` 属于线程的私有变量，如果使用的是线程池，那么 `ThreadLocal` 中的变量是可以重复使用的，而代码级别的局部变量，每次执行时都会创建新的局部变量，二者区别如下图所示：

![ee31bfd2b21773e67b4ddcabbd4e930c.png][]

更多关于 `ThreadLocal` 的内容，可以访问磊哥前面的文章[《ThreadLocal不好用？那是你没用对！》][ThreadLocal]。

#### ⑤ 使用DateTimeFormatter ####

以上 4 种解决方案都是因为 `SimpleDateFormat` 是线程不安全的，所以我们需要加锁或者使用 `ThreadLocal` 来处理，然而，`JDK 8` 之后我们就有了新的选择，如果使用的是 `JDK 8+` 版本，就可以直接使用 `JDK 8` 中新增的、安全的时间格式化工具类 `DateTimeFormatter` 来格式化时间了，接下来我们来具体实现一下。

使用 `DateTimeFormatter` 必须要配合 `JDK 8` 中新增的时间对象 `LocalDateTime` 来使用，因此在操作之前，我们可以先将 `Date` 对象转换成 `LocalDateTime`，然后再通过 `DateTimeFormatter` 来格式化时间，具体实现代码如下：

import java.time.LocalDateTime;
    import java.time.ZoneId;
    import java.time.format.DateTimeFormatter;
    import java.util.Date;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /**
     * DateTimeFormatter 解决线程不安全问题
     */
    public class SimpleDateFormatExample5 {
        // 创建 DateTimeFormatter 对象
        private static DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("mm:ss");
    
        public static void main(String[] args) {
            // 创建线程池
            ExecutorService threadPool = Executors.newFixedThreadPool(10);
            // 执行 10 次时间格式化
            for (int i = 0; i < 10; i++) {
                int finalI = i;
                // 线程池执行任务
                threadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        // 创建时间对象
                        Date date = new Date(finalI * 1000);
                        // 将 Date 转换成 JDK 8 中的时间类型 LocalDateTime
                        LocalDateTime localDateTime =
                                LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
                        // 时间格式化
                        String result = dateTimeFormatter.format(localDateTime);
                        // 打印结果
                        System.out.println(result);
                    }
                });
            }
            // 任务执行完之后关闭线程池
            threadPool.shutdown();
        }
    }

以上程序的执行结果为：

![66802405551bcda7d27c78de4f75f22b.png][]

### 3.线程不安全原因分析 ###

要了解 `SimpleDateFormat` 为什么是线程不安全的？我们需要查看并分析 `SimpleDateFormat` 的源码才行，那我们先从使用的方法 `format` 入手，源码如下：

private StringBuffer format(Date date, StringBuffer toAppendTo,
                                    FieldDelegate delegate) {
        // 注意此行代码
        calendar.setTime(date);
    
        boolean useDateFormatSymbols = useDateFormatSymbols();
    
        for (int i = 0; i < compiledPattern.length; ) {
            int tag = compiledPattern[i] >>> 8;
            int count = compiledPattern[i++] & 0xff;
            if (count == 255) {
                count = compiledPattern[i++] << 16;
                count |= compiledPattern[i++];
            }
    
            switch (tag) {
                case TAG_QUOTE_ASCII_CHAR:
                    toAppendTo.append((char)count);
                    break;
    
                case TAG_QUOTE_CHARS:
                    toAppendTo.append(compiledPattern, i, count);
                    i += count;
                    break;
    
                default:
                    subFormat(tag, count, delegate, toAppendTo, useDateFormatSymbols);
                    break;
            }
        }
        return toAppendTo;
    }

也许是好运使然，没想到刚开始分析第一个方法就找到了线程不安全的问题所在。

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

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

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

![cb460b47325496741fefc28f134cb8a1.png][]

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

![e53109ff2d52b58ff3aa7672471ac58a.png][]在多线程执行的情况下，线程 1 的 `date1` 和线程 2 的 `date2`，因为执行顺序的问题，最终都被格式化成 `date2 formatted`，而非线程 1 `date1 formatted` 和线程 2 `date2 formatted`，这样就会导致线程不安全的问题。

### 4.各方案优缺点总结 ###

如果**使用的是 `JDK 8+` 版本，可以直接使用线程安全的 `DateTimeFormatter` 来进行时间格式化**，**如果使用的 `JDK 8` 以下版本或者改造老的 `SimpleDateFormat` 代码，可以考虑使用 `synchronized` 或 `ThreadLocal` 来解决线程不安全的问题**。因为实现方案 1 局部变量的解决方案，每次执行的时候都会创建新的对象，因此不推荐使用。**`synchronized` 的实现比较简单，而使用 `ThreadLocal` 可以避免加锁排队执行的问题。**

![e21a10fccab8a97609000ffdc8cdb383.gif][]

往期推荐

[![a507504f4a309eeac3d553192d9bb8af.png][]][a507504f4a309eeac3d553192d9bb8af.png 1]

[ThreadLocal不好用？那是你没用对！][a507504f4a309eeac3d553192d9bb8af.png 1]

[![4cc217e1e57e77c02cf56dffae7ea149.png][]][4cc217e1e57e77c02cf56dffae7ea149.png 1]

[Semaphore自白：限流器用我就对了！][4cc217e1e57e77c02cf56dffae7ea149.png 1]

[![78fa29b2635e84e9d495bb5567ad6b01.png][]][78fa29b2635e84e9d495bb5567ad6b01.png 1]

[额！Java中用户线程和守护线程区别这么大？][78fa29b2635e84e9d495bb5567ad6b01.png 1]

[783e761ce3561820840361d75770d367.png]: https://img-blog.csdnimg.cn/img_convert/783e761ce3561820840361d75770d367.png
[04ba307bbfca8c00b2368b50c1d12f35.png]: https://img-blog.csdnimg.cn/img_convert/04ba307bbfca8c00b2368b50c1d12f35.png
[fa73b745db7fedec1f769893b36cf451.png]: https://img-blog.csdnimg.cn/img_convert/fa73b745db7fedec1f769893b36cf451.png
[df41dcdc4ee8f0952942791634aa4793.png]: https://img-blog.csdnimg.cn/img_convert/df41dcdc4ee8f0952942791634aa4793.png
[a2acce0e2714b9c5a24f2ccbe10edfcd.png]: https://img-blog.csdnimg.cn/img_convert/a2acce0e2714b9c5a24f2ccbe10edfcd.png
[e87685c151e9049f556ff3e38147644a.png]: https://img-blog.csdnimg.cn/img_convert/e87685c151e9049f556ff3e38147644a.png
[a4048dc86113a72a375e0f682fe684a6.png]: https://img-blog.csdnimg.cn/img_convert/a4048dc86113a72a375e0f682fe684a6.png
[ed9b004daa03403c06af3891281426bb.png]: https://img-blog.csdnimg.cn/img_convert/ed9b004daa03403c06af3891281426bb.png
[4443058083b06e46feb145beea2f57e5.png]: https://img-blog.csdnimg.cn/img_convert/4443058083b06e46feb145beea2f57e5.png
[ee31bfd2b21773e67b4ddcabbd4e930c.png]: https://img-blog.csdnimg.cn/img_convert/ee31bfd2b21773e67b4ddcabbd4e930c.png
[ThreadLocal]: https://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&idx=1&mid=2247495485&scene=21&sn=d09a6c32f61699c54c860fd5879ae14b#wechat_redirect
[66802405551bcda7d27c78de4f75f22b.png]: https://img-blog.csdnimg.cn/img_convert/66802405551bcda7d27c78de4f75f22b.png
[cb460b47325496741fefc28f134cb8a1.png]: https://img-blog.csdnimg.cn/img_convert/cb460b47325496741fefc28f134cb8a1.png
[e53109ff2d52b58ff3aa7672471ac58a.png]: https://img-blog.csdnimg.cn/img_convert/e53109ff2d52b58ff3aa7672471ac58a.png
[e21a10fccab8a97609000ffdc8cdb383.gif]: https://img-blog.csdnimg.cn/img_convert/e21a10fccab8a97609000ffdc8cdb383.gif
[a507504f4a309eeac3d553192d9bb8af.png]: https://img-blog.csdnimg.cn/img_convert/a507504f4a309eeac3d553192d9bb8af.png
[a507504f4a309eeac3d553192d9bb8af.png 1]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf8205ccb80b137afe1b71787cd9b5484c9a0afcd5f22a9c47f1fe72cba879dd5bb23d7384&idx=1&mid=2247495485&scene=21&sn=d09a6c32f61699c54c860fd5879ae14b#wechat_redirect
[4cc217e1e57e77c02cf56dffae7ea149.png]: https://img-blog.csdnimg.cn/img_convert/4cc217e1e57e77c02cf56dffae7ea149.png
[4cc217e1e57e77c02cf56dffae7ea149.png 1]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf8325ccb80a332977b10d31ff0ea07be3fb91c7f4cb696605c38d5ac4258167c46bbf62e3&idx=1&mid=2247495197&scene=21&sn=12b9e794ea7f425cd50b2b79cf0aa80b#wechat_redirect
[78fa29b2635e84e9d495bb5567ad6b01.png]: https://img-blog.csdnimg.cn/img_convert/78fa29b2635e84e9d495bb5567ad6b01.png
[78fa29b2635e84e9d495bb5567ad6b01.png 1]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf835eccb80a48d244250ca7d6725de2a72091602994e402b97b51e5f4b63f8ecbf2c60f99&idx=1&mid=2247495270&scene=21&sn=33c3316028dd1cb8883e63da328fdbd4#wechat_redirect