为什么阿里巴巴禁止把SimpleDateFormat定义为static类型的？线程不安全原因及解决办法

最新推荐文章于 2022-08-07 16:35:53 发布
最新推荐文章于 2022-08-07 16:35:53 发布
阅读量528 收藏 2
点赞数 3
分类专栏： 项目实战
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuerchong/article/details/119592607
版权

在日常开发中，我们经常会用到时间相关类，我们有很多办法在Java代码中获取时间。但是不同的方法获取到的时间的格式都不尽相同，这时候就需要一种格式化工具，把时间显示成我们需要的格式。

最常用的方法就是使用SimpleDateFormat类。这是一个看上去功能比较简单的类，但是，一旦使用不当也有可能导致很大的问题。

在阿里巴巴Java开发手册中，有如下明确规定：

SimpleDateFormat 不允许定义为satic 若定义为static 必须枷锁或者用dateUtils类

那么，本文就围绕SimpleDateFormat的用法、原理等来深入分析下如何以正确的姿势使用它。

重现SimpleDateFormat类的线程安全问题

package com.liu.news.common.utils;


import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * @author lx
 * @version 1.0
 * @description: 测试SimpleDateFormat的线程不安全问题
 * @date 2021/8/11 8:06
 */


public class SimpleDateFormatTest01 {
    //执行总次数
    private static final int EXECUTE_COUNT = 1000;
    //同时运行的线程数量
    private static final int THREAD_COUNT = 20;
    //SimpleDateFormat对象
    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");

    public static void main(String[] args) throws InterruptedException {
        final Semaphore semaphore = new Semaphore(THREAD_COUNT);
        final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < EXECUTE_COUNT; i++){
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    try {
                        Date date = simpleDateFormat.parse("2021-08-01");
                        System.out.println(date);
                    } catch (ParseException e) {

                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
                        e.printStackTrace();
                        System.exit(1);
                    }catch (NumberFormatException e){
                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
                        e.printStackTrace();
                        System.exit(1);
                    }
                    semaphore.release();
                } catch (InterruptedException e) {
                    System.out.println("信号量发生错误");
                    e.printStackTrace();
                    System.exit(1);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("所有线程格式化日期成功");
    }
}

运行程序，结果如下

D:\soft\jdk\jdk1.8.0_45\bin\java.exe -javaagent:C:\Users\lx\.IntelliJIdea2018.3\system\testAgent\intellij-coverage-agent-1.0.495.jar=C:\Users\lx\AppData\Local\Temp\coverage1args "-javaagent:D:\soft\idea\IntelliJ IDEA 2018.3.2\lib\idea_rt.jar=13822:D:\soft\idea\IntelliJ IDEA 2018.3.2\bin" -Dfile.encoding=UTF-8 -classpath D:\soft\jdk\jdk1.8.0_45\jre\lib\charsets.jar;D:\soft\jdk\jdk1.8.0_45\jre\lib\deploy.jar;D:\soft\jdk\jdk1.8.0_45\jre\lib\ext\access-bridge-64.jar;D:\soft\jdk\jdk1.8.0_45\jre\lib\ext\cldrdata.jar;D:\soft\jdk\jdk1.8.0_45\jre\lib\ext\dnsns.jar;D:\soft\jdk\jdk1.8.0_45\jre\lib\ext\jaccess.jar;D:\soft\jdk\jdk1.8.0_45\jre\lib\ext\jfxrt.jar;D:\soft\jdk\jdk1.8.0_45\jre\lib\ext\localedata.jar;D:\soft\jdk\jdk1.8.0_45\jre\lib\ext\nashorn.jar;D:\soft\jdk\jdk1.8.0_45\jre\lib\ext\sunec.jar;D:\soft\jdk\jdk1.8.0_45\jre\lib\ext\sunjce_provider.jar;D:\soft\jdk\jdk1.8.0_45\jre\lib\ext\sunmscapi.jar;D:\soft\jdk\jdk1.8.0_45\jre\lib\ext\sunpkcs11.jar;D:\soft\jdk\jdk1.8.0_45\jre\lib\ext\zipfs.jar;D:\soft\jdk\jdk1.8.0_45\jre\lib\javaws.jar;D:\soft\jdk\jdk1.8.0_45\jre\lib\jce.jar;D:\soft\jdk\jdk1.8.0_45\jre\lib\jfr.jar;D:\soft\jdk\jdk1.8.0_45\jre\lib\jfxswt.jar;D:\soft\jdk\jdk1.8.0_45\jre\lib\jsse.jar;D:\soft\jdk\jdk1.8.0_45\jre\lib\management-agent.jar;D:\soft\jdk\jdk1.8.0_45\jre\lib\plugin.jar;D:\soft\jdk\jdk1.8.0_45\jre\lib\resources.jar;D:\soft\jdk\jdk1.8.0_45\jre\lib\rt.jar;E:\daima\nacosYM\newsartical\artical-common\artical-common-utils\target\classes;D:\env\repo\cn\hutool\hutool-all\5.7.4\hutool-all-5.7.4.jar;D:\env\repo\org\projectlombok\lombok\1.18.20\lombok-1.18.20.jar;D:\env\repo\org\apache\commons\commons-lang3\3.11\commons-lang3-3.11.jar;D:\env\repo\org\apache\commons\commons-collections4\4.4\commons-collections4-4.4.jar;D:\env\repo\commons-configuration\commons-configuration\1.10\commons-configuration-1.10.jar;D:\env\repo\commons-lang\commons-lang\2.6\commons-lang-2.6.jar;D:\env\repo\commons-logging\commons-logging\1.1.1\commons-logging-1.1.1.jar;D:\env\repo\com\alibaba\fastjson\1.2.76\fastjson-1.2.76.jar com.liu.news.common.utils.SimpleDateFormatTest01
---- IntelliJ IDEA coverage runner ---- 
sampling ...
include patterns:
com\.liu\.news\.common\.utils\..*
exclude patterns:
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sat Jan 01 00:00:00 CST 1686856
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Mon Aug 01 00:00:00 CST 1
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
线程：pool-1-thread-3 格式化日期失败
线程：pool-1-thread-4 格式化日期失败
java.lang.NumberFormatException: multiple points
	at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1890)
	at sun.misc.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
	at java.lang.Double.parseDouble(Double.java:538)
	at java.text.DigitList.getDouble(DigitList.java:169)
	at java.text.DecimalFormat.parse(DecimalFormat.java:2056)
	at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1869)
	at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
	at java.text.DateFormat.parse(DateFormat.java:364)
	at com.liu.news.common.utils.SimpleDateFormatTest01.lambda$main$0(SimpleDateFormatTest01.java:37)
	at com.liu.news.common.utils.SimpleDateFormatTest01$$Lambda$1/500977346.run(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
	at java.lang.Thread.run(Thread.java:745)
Sun Aug 01 00:00:00 CST 2021
java.lang.NumberFormatException: multiple points
	at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1890)
	at sun.misc.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
	at java.lang.Double.parseDouble(Double.java:538)
	at java.text.DigitList.getDouble(DigitList.java:169)
	at java.text.DecimalFormat.parse(DecimalFormat.java:2056)
	at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1869)
	at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
	at java.text.DateFormat.parse(DateFormat.java:364)
	at com.liu.news.common.utils.SimpleDateFormatTest01.lambda$main$0(SimpleDateFormatTest01.java:37)
	at com.liu.news.common.utils.SimpleDateFormatTest01$$Lambda$1/500977346.run(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
	at java.lang.Thread.run(Thread.java:745)
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
线程：pool-1-thread-8 格式化日期失败
java.lang.NumberFormatException: multiple points
线程：pool-1-thread-7 格式化日期失败
	at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1890)
	at sun.misc.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
	at java.lang.Double.parseDouble(Double.java:538)
	at java.text.DigitList.getDouble(DigitList.java:169)
	at java.text.DecimalFormat.parse(DecimalFormat.java:2056)
	at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1869)
	at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
	at java.text.DateFormat.parse(DateFormat.java:364)
	at com.liu.news.common.utils.SimpleDateFormatTest01.lambda$main$0(SimpleDateFormatTest01.java:37)
	at com.liu.news.common.utils.SimpleDateFormatTest01$$Lambda$1/500977346.run(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
	at java.lang.Thread.run(Thread.java:745)
java.lang.NumberFormatException: multiple points
	at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1890)
	at sun.misc.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
	at java.lang.Double.parseDouble(Double.java:538)
	at java.text.DigitList.getDouble(DigitList.java:169)
	at java.text.DecimalFormat.parse(DecimalFormat.java:2056)
	at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1869)
	at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
	at java.text.DateFormat.parse(DateFormat.java:364)
	at com.liu.news.common.utils.SimpleDateFormatTest01.lambda$main$0(SimpleDateFormatTest01.java:37)
	at com.liu.news.common.utils.SimpleDateFormatTest01$$Lambda$1/500977346.run(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
	at java.lang.Thread.run(Thread.java:745)
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Wed Aug 11 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sat Aug 01 00:00:00 CST 11
线程：pool-1-thread-15 格式化日期失败
java.lang.NumberFormatException: multiple points
	at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1890)
	at sun.misc.FloatingDecimal.parseDouble(FloatingDecimal.java:110)Sun Aug 01 00:00:00 CST 2021

	at java.lang.Double.parseDouble(Double.java:538)
线程：pool-1-thread-12 格式化日期失败	at java.text.DigitList.getDouble(DigitList.java:169)

	at java.text.DecimalFormat.parse(DecimalFormat.java:2056)
	at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1869)
	at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
	at java.text.DateFormat.parse(DateFormat.java:364)
	at com.liu.news.common.utils.SimpleDateFormatTest01.lambda$main$0(SimpleDateFormatTest01.java:37)
	at com.liu.news.common.utils.SimpleDateFormatTest01$$Lambda$1/500977346.run(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
	at java.lang.Thread.run(Thread.java:745)
Sun Aug 01 00:00:00 CST 2021
java.lang.NumberFormatException: multiple points
Sun Aug 01 00:00:00 CST 2021
	at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1890)
Sun Aug 01 00:00:00 CST 2021
	at sun.misc.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
	at java.lang.Double.parseDouble(Double.java:538)
	at java.text.DigitList.getDouble(DigitList.java:169)
	at java.text.DecimalFormat.parse(DecimalFormat.java:2056)
	at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1869)
	at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
	at java.text.DateFormat.parse(DateFormat.java:364)
	at com.liu.news.common.utils.SimpleDateFormatTest01.lambda$main$0(SimpleDateFormatTest01.java:37)
	at com.liu.news.common.utils.SimpleDateFormatTest01$$Lambda$1/500977346.run(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
	at java.lang.Thread.run(Thread.java:745)
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
线程：pool-1-thread-20 格式化日期失败
java.lang.NumberFormatException: multiple points
线程：pool-1-thread-19 格式化日期失败
	at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1890)
	at sun.misc.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
	at java.lang.Double.parseDouble(Double.java:538)
	at java.text.DigitList.getDouble(DigitList.java:169)
	at java.text.DecimalFormat.parse(DecimalFormat.java:2056)
	at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1869)
	at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
	at java.text.DateFormat.parse(DateFormat.java:364)
	at com.liu.news.common.utils.SimpleDateFormatTest01.lambda$main$0(SimpleDateFormatTest01.java:37)
	at com.liu.news.common.utils.SimpleDateFormatTest01$$Lambda$1/500977346.run(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
	at java.lang.Thread.run(Thread.java:745)
java.lang.NumberFormatException: multiple points
Sun Aug 01 00:00:00 CST 2021	at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1890)
	at sun.misc.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
	at java.lang.Double.parseDouble(Double.java:538)
	at java.text.DigitList.getDouble(DigitList.java:169)
	at java.text.DecimalFormat.parse(DecimalFormat.java:2056)
	at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1869)
	at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
	at java.text.DateFormat.parse(DateFormat.java:364)
	at com.liu.news.common.utils.SimpleDateFormatTest01.lambda$main$0(SimpleDateFormatTest01.java:37)
	at com.liu.news.common.utils.SimpleDateFormatTest01$$Lambda$1/500977346.run(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
	at java.lang.Thread.run(Thread.java:745)

Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
线程：pool-1-thread-44 格式化日期失败
Fri May 01 00:00:00 CST 2189
Fri May 01 00:00:00 CST 2189
java.lang.NumberFormatException: For input string: ""
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Long.parseLong(Long.java:601)
	at java.lang.Long.parseLong(Long.java:631)
	at java.text.DigitList.getLong(DigitList.java:195)
	at java.text.DecimalFormat.parse(DecimalFormat.java:2051)
	at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1869)
	at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
Sun Aug 01 00:00:00 CST 2021
	at java.text.DateFormat.parse(DateFormat.java:364)
	at com.liu.news.common.utils.SimpleDateFormatTest01.lambda$main$0(SimpleDateFormatTest01.java:37)
	at com.liu.news.common.utils.SimpleDateFormatTest01$$Lambda$1/500977346.run(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
	at java.lang.Thread.run(Thread.java:745)
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
线程：pool-1-thread-43 格式化日期失败
java.lang.NumberFormatException: For input string: ""
Sun Aug 01 00:00:00 CST 1
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Long.parseLong(Long.java:601)
	at java.lang.Long.parseLong(Long.java:631)
Sun Aug 01 00:00:00 CST 2021	at java.text.DigitList.getLong(DigitList.java:195)

	at java.text.DecimalFormat.parse(DecimalFormat.java:2051)
	at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1869)
	at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
	at java.text.DateFormat.parse(DateFormat.java:364)
	at com.liu.news.common.utils.SimpleDateFormatTest01.lambda$main$0(SimpleDateFormatTest01.java:37)
	at com.liu.news.common.utils.SimpleDateFormatTest01$$Lambda$1/500977346.run(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
	at java.lang.Thread.run(Thread.java:745)
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Mon Aug 01 00:00:00 CST 2022
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Mon Aug 01 00:00:00 CST 2022
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
线程：pool-1-thread-60 格式化日期失败
java.lang.NumberFormatException: multiple points
	at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1890)
线程：pool-1-thread-51 格式化日期失败
	at sun.misc.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
	at java.lang.Double.parseDouble(Double.java:538)
	at java.text.DigitList.getDouble(DigitList.java:169)
	at java.text.DecimalFormat.parse(DecimalFormat.java:2056)
	at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1869)
	at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
	at java.text.DateFormat.parse(DateFormat.java:364)
Sun Aug 01 00:00:00 CST 2021
	at com.liu.news.common.utils.SimpleDateFormatTest01.lambda$main$0(SimpleDateFormatTest01.java:37)
	at com.liu.news.common.utils.SimpleDateFormatTest01$$Lambda$1/500977346.run(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
	at java.lang.Thread.run(Thread.java:745)
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
java.lang.NumberFormatException: multiple points
	at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1890)
Sun Aug 01 00:00:00 CST 2021
	at sun.misc.FloatingDecimal.parseDouble(FloatingDecimal.java:110)Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 1
Sun Aug 01 00:00:00 CST 1
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021

	at java.lang.Double.parseDouble(Double.java:538)
	at java.text.DigitList.getDouble(DigitList.java:169)
	at java.text.DecimalFormat.parse(DecimalFormat.java:2056)
	at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1869)
	at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
	at java.text.DateFormat.parse(DateFormat.java:364)
	at com.liu.news.common.utils.SimpleDateFormatTest01.lambda$main$0(SimpleDateFormatTest01.java:37)
	at com.liu.news.common.utils.SimpleDateFormatTest01$$Lambda$1/500977346.run(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
	at java.lang.Thread.run(Thread.java:745)
Sun Aug 01 00:00:00 CST 2021
Class transformation time: 0.1343094s for 306 classes or 4.389196078431372E-4s per class
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sat Jul 31 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
线程：pool-1-thread-637 格式化日期失败
Sun Aug 01 00:00:00 CST 2021java.lang.NumberFormatException: For input string: ""

	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Long.parseLong(Long.java:601)
	at java.lang.Long.parseLong(Long.java:631)
	at java.text.DigitList.getLong(DigitList.java:195)
	at java.text.DecimalFormat.parse(DecimalFormat.java:2051)
	at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1869)
Wed Dec 01 00:00:00 CST 2021
	at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
	at java.text.DateFormat.parse(DateFormat.java:364)
	at com.liu.news.common.utils.SimpleDateFormatTest01.lambda$main$0(SimpleDateFormatTest01.java:37)
	at com.liu.news.common.utils.SimpleDateFormatTest01$$Lambda$1/500977346.run(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
	at java.lang.Thread.run(Thread.java:745)
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Mon Oct 01 00:00:00 CST 2187
Mon Dec 01 00:00:00 CST 1969
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Tue Dec 01 00:00:00 CST 2020
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021
Mon Aug 01 00:00:00 CST 1
Sun Aug 01 00:00:00 CST 2021
Mon Oct 01 00:00:00 CST 2187
Sun Aug 01 00:00:00 CST 2021
Sun Aug 01 00:00:00 CST 2021

Process finished with exit code 1

解决SimpleDateFormat类的线程安全问题

1.局部变量法

最简单的一种方式就是将SimpleDateFormat类对象定义成局部变量，如下所示的代码，将SimpleDateFormat类对象定义在parse(String)方法的上面，即可解决问题。

package com.liu.news.common.utils;


import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * @author lx
 * @version 1.0
 * @description: 测试SimpleDateFormat的线程不安全问题
 * @date 2021/8/11 8:06
 */


public class SimpleDateFormatTest01 {
    //执行总次数
    private static final int EXECUTE_COUNT = 1000;
    //同时运行的线程数量
    private static final int THREAD_COUNT = 20;
    //SimpleDateFormat对象
   // private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");

    public static void main(String[] args) throws InterruptedException {
        final Semaphore semaphore = new Semaphore(THREAD_COUNT);
        final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < EXECUTE_COUNT; i++){
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    try {
                        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
                        Date date = simpleDateFormat.parse("2021-08-01");
                        System.out.println(date);
                    } catch (ParseException e) {

                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
                        e.printStackTrace();
                        System.exit(1);
                    }catch (NumberFormatException e){
                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
                        e.printStackTrace();
                        System.exit(1);
                    }
                    semaphore.release();
                } catch (InterruptedException e) {
                    System.out.println("信号量发生错误");
                    e.printStackTrace();
                    System.exit(1);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("所有线程格式化日期成功");
    }
}

所有线程格式化日期成功
Class transformation time: 0.1085764s for 293 classes or 3.7056791808873723E-4s per class

不足之处
这种方式在高并发下会创建大量的SimpleDateFormat类对象，影响程序的性能，所以，这种方式在实际生产环境不太被推荐。

synchronized锁方式

将SimpleDateFormat类对象定义成全局静态变量，此时所有线程共享SimpleDateFormat类对象，此时在调用格式化时间的方法时，对SimpleDateFormat对象进行同步即可，代码如下所示。

package com.liu.news.common.utils;


import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * @author lx
 * @version 1.0
 * @description: 测试SimpleDateFormat的线程不安全问题
 * @date 2021/8/11 8:06
 */


public class SimpleDateFormatTest01 {
    //执行总次数
    private static final int EXECUTE_COUNT = 1000;
    //同时运行的线程数量
    private static final int THREAD_COUNT = 20;
    //SimpleDateFormat对象
    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");

    public static void main(String[] args) throws InterruptedException {
        final Semaphore semaphore = new Semaphore(THREAD_COUNT);
        final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < EXECUTE_COUNT; i++){
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    try {
                       // SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
                        synchronized (simpleDateFormat) {
                            Date date = simpleDateFormat.parse("2021-08-01");
                            System.out.println(date);
                        }
                    } catch (ParseException e) {

                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
                        e.printStackTrace();
                        System.exit(1);
                    }catch (NumberFormatException e){
                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
                        e.printStackTrace();
                        System.exit(1);
                    }
                    semaphore.release();
                } catch (InterruptedException e) {
                    System.out.println("信号量发生错误");
                    e.printStackTrace();
                    System.exit(1);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("所有线程格式化日期成功");
    }
}

不足

虽然这种方式能够解决SimpleDateFormat类的线程安全问题，但是由于在程序的执行过程中，为SimpleDateFormat类对象加上了synchronized锁，导致同一时刻只能有一个线程执行parse(String)方法。此时，会影响程序的执行性能，在要求高并发的生产环境下，此种方式也是不太推荐使用的。

Lock锁方式

Lock锁方式与synchronized锁方式实现原理相同，都是在高并发下通过JVM的锁机制来保证程序的线程安全。通过Lock锁方式解决问题的代码如下所示。

package com.liu.news.common.utils;


import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author lx
 * @version 1.0
 * @description: 测试SimpleDateFormat的线程不安全问题
 * @date 2021/8/11 8:06
 */


public class SimpleDateFormatTest01 {
    //执行总次数
    private static final int EXECUTE_COUNT = 1000;
    //同时运行的线程数量
    private static final int THREAD_COUNT = 20;
    //SimpleDateFormat对象
    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");

    //Lock对象
    private static Lock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        final Semaphore semaphore = new Semaphore(THREAD_COUNT);
        final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < EXECUTE_COUNT; i++){
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    try {
                       // SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
                       // synchronized (simpleDateFormat) {
                        lock.lock();
                        Date date = simpleDateFormat.parse("2021-08-01");
                        System.out.println(date);
                      //  }
                    } catch (ParseException e) {

                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
                        e.printStackTrace();
                        System.exit(1);
                    }catch (NumberFormatException e){
                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
                        e.printStackTrace();
                        System.exit(1);
                    }
                    finally {
                        lock.unlock();
                    }
                    semaphore.release();
                } catch (InterruptedException e) {
                    System.out.println("信号量发生错误");
                    e.printStackTrace();
                    System.exit(1);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("所有线程格式化日期成功");
    }
}

通过代码可以得知，首先，定义了一个Lock类型的全局静态变量作为加锁和释放锁的句柄。然后在simpleDateFormat.parse(String)代码之前通过lock.lock()加锁。这里需要注意的一点是：为防止程序抛出异常而导致锁不能被释放，一定要将释放锁的操作放到finally代码块中

此种方式同样会影响高并发场景下的性能，不太建议在高并发的生产环境使用。

ThreadLocal方式

使用ThreadLocal存储每个线程拥有的SimpleDateFormat对象的副本，能够有效的避免多线程造成的线程安全问题，使用ThreadLocal解决线程安全问题的代码如下所示。

package com.liu.news.common.utils;


import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * @author lx
 * @version 1.0
 * @description: 测试SimpleDateFormat的线程不安全问题
 * @date 2021/8/11 8:06
 */


public class SimpleDateFormatTest01 {
    //执行总次数
    private static final int EXECUTE_COUNT = 1000;
    //同时运行的线程数量
    private static final int THREAD_COUNT = 20;
    //SimpleDateFormat对象
   // private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");

    //Lock对象
   // private static Lock lock = new ReentrantLock();
    private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>(){
        @Override
        protected DateFormat initialValue() {
            return new SimpleDateFormat("yyyy-MM-dd");
        }
    };

    public static void main(String[] args) throws InterruptedException {
        final Semaphore semaphore = new Semaphore(THREAD_COUNT);
        final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < EXECUTE_COUNT; i++){
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    try {
                       // SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
                       // synchronized (simpleDateFormat) {
                        //lock.lock();
                        Date date = threadLocal.get().parse("2021-08-01");
                        System.out.println(date);
                      //  }
                    } catch (ParseException e) {

                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
                        e.printStackTrace();
                        System.exit(1);
                    }catch (NumberFormatException e){
                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
                        e.printStackTrace();
                        System.exit(1);
                    }
                    /*finally {
                        lock.unlock();
                    }*/
                    semaphore.release();
                } catch (InterruptedException e) {
                    System.out.println("信号量发生错误");
                    e.printStackTrace();
                    System.exit(1);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("所有线程格式化日期成功");
    }
}



package com.liu.news.common.utils;


import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * @author lx
 * @version 1.0
 * @description: 测试SimpleDateFormat的线程不安全问题
 * @date 2021/8/11 8:06
 */


public class SimpleDateFormatTest01 {
    //执行总次数
    private static final int EXECUTE_COUNT = 1000;
    //同时运行的线程数量
    private static final int THREAD_COUNT = 20;
    //SimpleDateFormat对象
   // private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");

    //Lock对象
   // private static Lock lock = new ReentrantLock();
   /* private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>(){
        @Override
        protected DateFormat initialValue() {
            return new SimpleDateFormat("yyyy-MM-dd");
        }
    };*/
    private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>();

    private static DateFormat getDateFormat(){
        DateFormat dateFormat = threadLocal.get();
        if(dateFormat == null){
            dateFormat = new SimpleDateFormat("yyyy-MM-dd");
            threadLocal.set(dateFormat);
        }
        return dateFormat;
    }

    public static void main(String[] args) throws InterruptedException {
        final Semaphore semaphore = new Semaphore(THREAD_COUNT);
        final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < EXECUTE_COUNT; i++){
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    try {
                       // SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
                       // synchronized (simpleDateFormat) {
                        //lock.lock();
                        Date date = getDateFormat().parse("2021-08-01");
                        System.out.println(date);
                      //  }
                    } catch (ParseException e) {

                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
                        e.printStackTrace();
                        System.exit(1);
                    }catch (NumberFormatException e){
                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
                        e.printStackTrace();
                        System.exit(1);
                    }
                    /*finally {
                        lock.unlock();
                    }*/
                    semaphore.release();
                } catch (InterruptedException e) {
                    System.out.println("信号量发生错误");
                    e.printStackTrace();
                    System.exit(1);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("所有线程格式化日期成功");
    }
}

通过代码可以得知，将每个线程使用的SimpleDateFormat副本保存在ThreadLocal中，各个线程在使用时互不干扰，从而解决了线程安全问题。

此种方式运行效率比较高，推荐在高并发业务场景的生产环境使用。

DateTimeFormatter方式

DateTimeFormatter是Java8提供的新的日期时间API中的类，DateTimeFormatter类是线程安全的，可以在高并发场景下直接使用DateTimeFormatter类来处理日期的格式化操作。代码如下所示。

package com.liu.news.common.utils;


import java.text.ParseException;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * @author lx
 * @version 1.0
 * @description: 测试SimpleDateFormat的线程不安全问题
 * @date 2021/8/11 8:06
 */


public class SimpleDateFormatTest01 {
    //执行总次数
    private static final int EXECUTE_COUNT = 1000;
    //同时运行的线程数量
    private static final int THREAD_COUNT = 20;
    //SimpleDateFormat对象
   // private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");

    //Lock对象
   // private static Lock lock = new ReentrantLock();
   /* private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>(){
        @Override
        protected DateFormat initialValue() {
            return new SimpleDateFormat("yyyy-MM-dd");
        }
    };*/
   // private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>();

   /* private static DateFormat getDateFormat(){
        DateFormat dateFormat = threadLocal.get();
        if(dateFormat == null){
            dateFormat = new SimpleDateFormat("yyyy-MM-dd");
            threadLocal.set(dateFormat);
        }
        return dateFormat;
    }*/

    private static DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

    public static void main(String[] args) throws InterruptedException {
        final Semaphore semaphore = new Semaphore(THREAD_COUNT);
        final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < EXECUTE_COUNT; i++){
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    try {
                       // SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
                       // synchronized (simpleDateFormat) {
                        //lock.lock();
                       // Date date = getDateFormat().parse("2021-08-01");
                        LocalDate date =  LocalDate.parse("2021-08-01", formatter);
                        System.out.println(date);
                      //  }
                    } catch (Exception e){
                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
                        e.printStackTrace();
                        System.exit(1);
                    }
                    /*finally {
                        lock.unlock();
                    }*/
                    semaphore.release();
                } catch (InterruptedException e) {
                    System.out.println("信号量发生错误");
                    e.printStackTrace();
                    System.exit(1);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("所有线程格式化日期成功");
    }
}

DateTimeFormatter类是线程安全的，可以在高并发场景下直接使用DateTimeFormatter类来处理日期的格式化操作。
使用DateTimeFormatter类来处理日期的格式化操作运行效率比较高，推荐在高并发业务场景的生产环境使用。

joda-time方式

joda-time是第三方处理日期时间格式化的类库，是线程安全的。如果使用joda-time来处理日期和时间的格式化，则需要引入第三方类库。这里，以Maven为例，如下所示引入joda-time库。

joda-time
joda-time
2.9.9

package com.liu.news.common.utils;


import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;

import java.util.Date;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * @author lx
 * @version 1.0
 * @description: 测试SimpleDateFormat的线程不安全问题
 * @date 2021/8/11 8:06
 */


public class SimpleDateFormatTest01 {
    //执行总次数
    private static final int EXECUTE_COUNT = 1000;
    //同时运行的线程数量
    private static final int THREAD_COUNT = 20;
    //SimpleDateFormat对象
   // private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");

    //Lock对象
   // private static Lock lock = new ReentrantLock();
   /* private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>(){
        @Override
        protected DateFormat initialValue() {
            return new SimpleDateFormat("yyyy-MM-dd");
        }
    };*/
   // private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>();

   /* private static DateFormat getDateFormat(){
        DateFormat dateFormat = threadLocal.get();
        if(dateFormat == null){
            dateFormat = new SimpleDateFormat("yyyy-MM-dd");
            threadLocal.set(dateFormat);
        }
        return dateFormat;
    }*/

    //private static DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    private static DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern("yyyy-MM-dd");
    public static void main(String[] args) throws InterruptedException {
        final Semaphore semaphore = new Semaphore(THREAD_COUNT);
        final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < EXECUTE_COUNT; i++){
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    try {
                       // SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
                       // synchronized (simpleDateFormat) {
                        //lock.lock();
                       // Date date = getDateFormat().parse("2021-08-01");
                        Date date = DateTime.parse("2021-08-01", dateTimeFormatter).toDate();
                        System.out.println(date);
                      //  }
                    } catch (Exception e){
                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
                        e.printStackTrace();
                        System.exit(1);
                    }
                    /*finally {
                        lock.unlock();
                    }*/
                    semaphore.release();
                } catch (InterruptedException e) {
                    System.out.println("信号量发生错误");
                    e.printStackTrace();
                    System.exit(1);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("所有线程格式化日期成功");
    }
}

DateTime类是org.joda.time包下的类，DateTimeFormat类和DateTimeFormatter类都是org.joda.time.format包下的类

使用joda-time库来处理日期的格式化操作运行效率比较高，推荐在高并发业务场景的生产环境使用。

解决SimpleDateFormat类的线程安全问题的方案总结

综上所示：在解决解决SimpleDateFormat类的线程安全问题的几种方案中，局部变量法由于线程每次执行格式化时间时，都会创建SimpleDateFormat类的对象，这会导致创建大量的SimpleDateFormat对象，浪费运行空间和消耗服务器的性能，因为JVM创建和销毁对象是要耗费性能的。所以，不推荐在高并发要求的生产环境使用。

synchronized锁方式和Lock锁方式在处理问题的本质上是一致的，通过加锁的方式，使同一时刻只能有一个线程执行格式化日期和时间的操作。这种方式虽然减少了SimpleDateFormat对象的创建，但是由于同步锁的存在，导致性能下降，所以，不推荐在高并发要求的生产环境使用。

ThreadLocal通过保存各个线程的SimpleDateFormat类对象的副本，使每个线程在运行时，各自使用自身绑定的SimpleDateFormat对象，互不干扰，执行性能比较高，推荐在高并发的生产环境使用。

DateTimeFormatter是Java 8中提供的处理日期和时间的类，DateTimeFormatter类本身就是线程安全的，经压测，DateTimeFormatter类处理日期和时间的性能效果还不错。所以，推荐在高并发场景下的生产环境使用。

joda-time是第三方处理日期和时间的类库，线程安全，性能经过高并发的考验，推荐在高并发场景下的生产环境使用。

liu1002880404
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
为什么禁止把SimpleDateFormat定义为static类型的？
hxt的博客
04-03 3345
一、前言 最近使用Sonarqube扫描代码的时候发现一个问题，使用static修饰SimpleDateFormat的实例被标记为了Bug Sonarqube中的提示信息如下： 并不是标准Java库中的所有类都被编写为线程安全的。以多线程方式使用它们很可能在运行时导致数据问题或异常 当Calendar, DateFormat, javax.xml.xpath.XPath, 或者 javax.xml...
Java中为什么禁止把SimpleDateFormat定位为static变量以及如果非要使用static定位SimpleDateFormat时在多线程环境下的几种使用方式
最新发布
BADAO_LIUMANG_QIZHI的博客
06-05 351
以下会用到如上概念。Java开发手册中对于SimpleDateFormat的使用的要求是:【强制】SimpleDateFormat 是线程不安全的类，一般不要定义为 static 变量，如果定义为 static，必须加锁，或者使用 DateUtils 工具类。正例：注意线程安全，使用 DateUtils。说明：如果是 JDK8 的应用，可以使用 Instant 代替 Date，LocalDateTime 代替 Calendar，
Java SimpleDateFormat不可设置为static final
沉默王二
07-11 3562
Java SimpleDateFormat不可设置为static final
SimpleDateFormat并不是一个线程安全的类
XT4625的专栏
02-28 784
一、前言 日常开发中，我们经常需要使用时间相关类，说到时间相关类，想必大家对SimpleDateFormat并不陌生。主要是用它进行时间的格式化输出和解析，挺方便快捷的，但是SimpleDateFormat并不是一个线程安全的类。在多线程情况下，会出现异常，想必有经验的小伙伴也遇到过。下面我们就来分析分析SimpleDateFormat为什么不安全？是怎么引发的？以及多线程下有那些SimpleD...
解读阿里巴巴Java手册：为什么禁止把SimpleDateFormat设为static
梦里蓝天
08-29 728
SimpleDateFormat介绍 SimpleDateFormat用于以区域设置敏感的方式格式化和解析日期。 它允许格式化（日期文本），解析（文本日期）和归一化。 日期和时间格式由日期和时间模式字符串指定。 在日期和时间模式字符串中，从’A’到’Z’和从’a’到’z’的非引号的字母被解释为表示日期或时间字符串的组件的模式字母。 可以使用单引号（ ’ ）引用文本，以避免解释。 "’’"代表单引号。 所有其他字符不被解释; 在格式化过程中，它们只是复制到输出字符串中，或者在解析过程中与输入字符串匹配。 例
大厂为何会禁止把SimpleDateFormat定义为static类型？
文章中资料均可获取，有需要请添加yunduoa2019即可
05-25 311
在日常开发中，我们经常会用到时间相关类，我们有很多办法在Java代码中获取时间。但是不同的方法获取到的时间的格式都不尽相同，这时候就需要一种格式化工具，把时间显示成我们需要的格式。 最常用的方法就是使用SimpleDateFormat类。这是一个看上去功能比较简单的类，但是，一旦使用不当也有可能导致很大的问题。 在阿里巴巴Java开发手册中，有如下明确规定： 那么，本文就围绕SimpleDateFormat的用法、原理等来深入分析下如何以正确的姿势使用它。 Simpl...
详解SimpleDateFormat的线程安全问题与解决方案
08-30
在Java编程中，`SimpleDateFormat`是一个常用的日期时间格式化工具类，但它的设计并不是线程安全的。本文将深入探讨`SimpleDateFormat`的线程安全问题及其解决方案。 ### 1. 线程安全问题的原因 `SimpleDateFormat...
SimpleDateFormat线程不安全的5种解决方案.docx
10-26
解决这一问题的方法有多种，包括将 SimpleDateFormat 定义为局部变量、使用 synchronized 或 Lock 进行同步控制、利用 ThreadLocal 创建线程私有的实例以及使用 JDK 8 中的 DateTimeFormatter。根据实际应用场景，...
ThreadLocal：如何优雅的解决SimpleDateFormat多线程安全问题
01-21
目录SimpleDateFormat诡异bug复现SimpleDateFormat诡异bug字符串日期转Date日期（parse）Date日期转String类型（format）SimpleDateFormat出现bug的原因如何解决SimpleDateFormat多线程安全问题局部变量使用...
为什么阿里巴巴要求日期格式化时必须有使用y表示年
08-18
阿里巴巴在编码规范中特别强调，在日期格式化时必须使用`y`表示年，而不是`Y`，这是因为两者之间存在重要的差异。本文将深入探讨这一规范背后的原因及其重要性。 `SimpleDateFormat`是Java提供的日期和时间格式化...
SimpleDateFormat线程不安全的5种解决方案.md
09-02
SimpleDateFormat线程不安全的5种解决方案.md
为什么阿里巴巴禁止把SimpleDateFormat定义为static类型的？
weixin_34362790的博客
12-05 1197
在日常开发中，我们经常会用到时间相关类，我们有很多办法在Java代码中获取时间。但是不同的方法获取到的时间的格式都不尽相同，这时候就需要一种格式化工具，把时间显示成我们需要的格式。最常用的方法就是使用SimpleDateFormat类。这是一个看上去功能比较简单的类，但是，一旦使用不当也有可能导致很大的问题。在阿里巴巴Java开发手册中，有如下明确规定：那么，本文就围绕Sim...
【牢记】非线程安全的类,尽量避免定义成全局静态变量(以SimpleDateFormat为例说明)
qq_42140188的博客
03-31 1727
前言： 在开发中,我们都使用过SimpleDateFormat这个类,更为了开发方便,减少SimpleDateFormat对象的创建,我们将它封装在了 DateUtil 工具类中,并将它定义成了全局静态的变量,这样减少了内存开销,那这样究竟行不行呢?jdk官方文档给了我们答案: 它的意思是说SimpleDateFormat中的日期格式是不同步的。推荐（建议）为每个线程创建独立的实例。如果多个...
Java日期格式化：DateFormat类和SimpleDateFormat类详解
GIS地图技术分享(GIS入门、Openlayers教程、Leaflet教程)，做最好的GIS地图开发教程
04-23 2413
前言 格式化日期表示将日期/时间格式转换为预先定义的日期/时间格式。 例如将日期“Fri May 18 15:46:24 CST2016” 格式转换为 “2016-5-18 15:46:24 星期五”的格式。 在 Java 中，可以使用 DateFormat 和 SimpleDateFormat 这两个类来格式化日期，下面详细介绍这两个格式化日期类的使用。 DateFormat 类 DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。日期/时间格式化子类（如
为什么阿里巴巴禁止把SimpleDateFormat定义为static类型的
Boush
08-07 287
在阿里巴巴Java开发手册（嵩山版）V1.7.0中，编程规范-（七）并发处理中强制要求： SimpleDateFormat 是线程不安全的类，一般不要定义为 static 变量
SimpleDateFormat的线程安全问题与解决方案
weixin_34153893的博客
08-29 354
1. 原因 SimpleDateFormat(下面简称sdf)类内部有一个Calendar对象引用,它用来储存和这个sdf相关的日期信息,例如sdf.parse(dateStr), sdf.format(date) 诸如此类的方法参数传入的日期相关String, Date等等, 都是交友Calendar引用来储存的.这样就会导致一个问题,如果你的sdf是个static的, 那么多个thread ...
为什么阿里Java规约要求谨慎使用SimpleDateFormat
weixin_34228617的博客
06-18 320
前言 在阿里Java开发规约中，有强制性的提到SimpleDateFormat 是线程不安全的类 ，在使用的时候应当注意线程安全问题，如下： 其实之前已经介绍过使用JDK1.8的DateTimeFormatter 和LocalDateTime来处理时间了，还在用SimpleDateFormat？Java8都发布N年了，转LocalDateTime吧。今天，就来说说SimpleDateFormat...
还在使用SimpleDateFormat？
weixin_34357887的博客
03-21 192
阅读本文大概需要 3.2 分钟。前言日常开发中，我们经常需要使用时间相关类，想必大家对SimpleDateFormat并不陌生。主要是用它进行时间的格式化输出和解析，挺方便快捷的，但是SimpleDateFormat并不是一个线程安全的类。在多线程情况下，会出现异常，想必有经验的小伙伴也遇到过。下面我们就来分析分析SimpleDateFormat为什么不安全？是怎么引发的？以及多线程下有那些Sim...
亲，建议你使用LocalDateTime而不是Date哦
wanghao112956的博客
09-11 505
在项目开发过程中经常遇到时间处理，但是你真的用对了吗，理解阿里巴巴开发手册中禁用static修饰SimpleDateFormat吗 通过阅读本篇文章你将了解到： 为什么需要LocalDate、LocalTime、LocalDateTime【java8新提供的类】 java8新的时间API的使用方式，包括创建、格式化、解析、计算、修改 （想自学习编程的小伙伴请搜索圈T社区，更多行业相关资讯更...
SimpleDateFormat线程不安全及解决办法
06-03
SimpleDateFormat是Java中用于格式化日期的类，它不是线程安全的。...这两种方法都可以解决SimpleDateFormat线程不安全的问题。但是在高并发场景下，ThreadLocal的性能可能比较差，因此建议使用DateTimeFormatter。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值