SimpleDateFormat学习使用

最新推荐文章于 2024-08-03 21:32:51 发布
最新推荐文章于 2024-08-03 21:32:51 发布
阅读量399 收藏 7
点赞数 6
分类专栏： Java 文章标签： 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44877172/article/details/135867951
版权

提起SimpleDateFormat类，想必做过Java开发的童鞋都不会感到陌生。没错，它就是Java中提供的日期时间的转化类。这里，
为什么说SimpleDateFormat类有线程安全问题呢？有些小伙伴可能会提出疑问：我们生产环境上一直在使用SimpleDateFormat
类来解析和格式化日期和时间类型的数据，一直都没有问题啊！我的回答是：没错，那是因为你们的系统达不到
SimpleDateFormat类出现问题的并发量，也就是说你们的系统没啥负载！
接下来，我们就一起看下在高并发下SimpleDateFormat类为何会出现安全问题，以及如何解决SimpleDateFormat类的安全问
题。

重现SimpleDateFormat线程安全问题

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.parse("2020-01-01");
                    } 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("所有线程格式化日期成功");
    }
}

运行结果

java.lang.NumberFormatException: For input string: ""
线程：pool-1-thread-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)
	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.xysd.concurrent.lab06.SimpleDateFormatTest01.lambda$main$0(SimpleDateFormatTest01.java:72)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:748)

原因

//SimpleDateFormat
public Date parse(String text, ParsePosition pos) {

        CalendarBuilder calb = new CalendarBuilder();
        Date parsedDate;
        try {
        	//TODO
            parsedDate = calb.establish(calendar).getTime();
            if (ambiguousYear[0]) {
                if (parsedDate.before(defaultCenturyStart)) {
                    parsedDate = calb.addYear(100).establish(calendar).getTime();
                }
            }
        }catch (IllegalArgumentException e) {
            pos.errorIndex = start;
            pos.index = oldStart;
            return null;
        }

        return parsedDate;
    }

//CalendarBuilder
//clear()和set()这两个方法执行不是原子操作所以造成线程不安全
Calendar establish(Calendar cal) {
        boolean weekDate = isSet(WEEK_YEAR)
                            && field[WEEK_YEAR] > field[YEAR];
        if (weekDate && !cal.isWeekDateSupported()) {
            // Use YEAR instead
            if (!isSet(YEAR)) {
                set(YEAR, field[MAX_FIELD + WEEK_YEAR]);
            }
            weekDate = false;
        }
		//这里线clear
        cal.clear();
        for (int stamp = MINIMUM_USER_STAMP; stamp < nextStamp; stamp++) {
            for (int index = 0; index <= maxFieldIndex; index++) {
                if (field[index] == stamp) {
                	//然后再set
                    cal.set(index, field[MAX_FIELD + index]);
                    break;
                }
            }
        }

        if (weekDate) {
            int weekOfYear = isSet(WEEK_OF_YEAR) ? field[MAX_FIELD + WEEK_OF_YEAR] : 1;
            int dayOfWeek = isSet(DAY_OF_WEEK) ?
                                field[MAX_FIELD + DAY_OF_WEEK] : cal.getFirstDayOfWeek();
            if (!isValidDayOfWeek(dayOfWeek) && cal.isLenient()) {
                if (dayOfWeek >= 8) {
                    dayOfWeek--;
                    weekOfYear += dayOfWeek / 7;
                    dayOfWeek = (dayOfWeek % 7) + 1;
                } else {
                    while (dayOfWeek <= 0) {
                        dayOfWeek += 7;
                        weekOfYear--;
                    }
                }
                dayOfWeek = toCalendarDayOfWeek(dayOfWeek);
            }
            cal.setWeekDate(field[MAX_FIELD + WEEK_YEAR], weekOfYear, dayOfWeek);
        }
        return cal;
    }

解决方案一 方法局部变量

public class SimpleDateFormatTest01 {
    //执行总次数
    private static final int EXECUTE_COUNT = 1000;
    //同时运行的线程数量
    private static final int THREAD_COUNT = 20;

    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");
                       simpleDateFormat.parse("2020-01-01");
                    } 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("所有线程格式化日期成功");
    }
}

解决方案二 使用synchronized锁

public class SimpleDateFormatTest01 {
    //执行总次数
    private static final int EXECUTE_COUNT = 1000;
    //同时运行的线程数量
    private static final int THREAD_COUNT = 20;
	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 {
                    	synchronized(simpleDateFormat){
                    	  simpleDateFormat.parse("2020-01-01");
                    	}
                    } 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("所有线程格式化日期成功");
    }
}

解决方案三 Lock锁

public class SimpleDateFormatTest01 {
    //执行总次数
    private static final int EXECUTE_COUNT = 1000;
    //同时运行的线程数量
    private static final int THREAD_COUNT = 20;
	private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
	private static Lock lock = new ReentrackLock();
	
    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 {
                    	lock.lock();
                    	simpleDateFormat.parse("2020-01-01");
                    } 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("所有线程格式化日期成功");
    }
}

解决方案四 ThreadLocal

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");

    //本地线程
    private static ThreadLocal<SimpleDateFormat> threadLocal = new ThreadLocal<SimpleDateFormat>() {
        @Override
        protected SimpleDateFormat initialValue() {
            return new SimpleDateFormat("yyyy-MM-dd");
        }
    };

    private static DateFormat getDateFormat() {
        SimpleDateFormat 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 {
                        getDateFormat().parse("2020-01-01");
                    } 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("所有线程格式化日期成功");
    }

}

解决方案五 DateTimeFormatter

public class SimpleDateFormatTest01 {

    //执行总次数
    private static final int EXECUTE_COUNT = 1000;
    //同时运行的线程数量
    private static final int THREAD_COUNT = 20;
    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 {
                        LocalDate.parse("2020-01-01", formatter);
                    } catch (Exception 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("所有线程格式化日期成功");
    }
}

总结

在高并发情况下推荐使用ThreadLocal或DateTimeFormatter

weixin_44877172
关注
  • 6
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SimpleDateFormat的简单使用
weixin_48182193的博客
02-04 2347
SimpleDateFormat的简单使用 Java中怎么才能把日期转换成想要的格式呢，或把字符串转换成一定格式的日期，如把数据库中的日期或时间转换成自己想要的格式，JAVA中提供了SimpleDateFormat类可以实现。 SimpleDateFormat 是一个各种项目中使用频度都很高的类，主要用于时间解析与格式化，频繁使用的主要方法有parse和format. parse方法：将字符串类型（java.lang.String）解析为日期类型（java.util.Date） format方法：将日期类型
8.3时间相关类代码.zip
08-09
5. 学习使用： - 对于初学者来说，理解并熟练运用这些类，可以提高编程效率，减少错误。例如，`StringTest.java`可能是在测试字符串与日期的转换，`TestDemo.java`可能演示了`Date`和`Calendar`的使用，而`...
SimpleDateformat的使用
qq_51447436的博客
03-12 3065
SimpleDateformat的使用
SimpleDateFormat的使用
weixin_44672631的博客
06-07 726
SimpleDateFormat的使用： SimpleDateFormat对日期Date类的格式化和解析 使用默认的构造器 1.两个操作： 1.1 格式化：日期 --->字符串 1.2 解析：格式化的逆过程，字符串 ---> 日期 2.SimpleDateFormat的实例化 //实例化SimpleDateFormat:使用默认的构造器 SimpleDateFormat sdf = new SimpleDateFormat(); //格式化：日期 --->字符串 Date date
时间类SimpleDateFormat的使用
m0_55895641的博客
02-24 249
import org.junit.Test; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; /** * @author * @create 2022-02-24-13:33 * jdk8之前的关于时间的API测试 * 1.System类中currentTimeMillis() * 2.java.util.Date和子类java.sql.date * 3.S.
学习Java，API接口simpledateformat
LegendApple的博客
06-19 91
php simpledateformat,simpledateformat
weixin_39658726的博客
03-17 284
模糊查询时间日期2021-03-15 23:01:52**模糊查询时间日期**在MySql数据库中，怎样去通过模糊查询时间日期去得到一条表中的数据，代码入下：// 创建一个时间对象Date date2 = new Date();// 设置时间格式SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");//获取String类型的时间java...
Java SimpleDateFormat
聚沙成塔
12-15 205
Java 日期格式化与解析是一项日常（痛苦的）任务，每天都让我们头痛不已。 通常使用SimpleDateFormat，下面是一个常见的日期工具类。 import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; public final class DateUt...
Date、Calendar、LocalDateTime、SimpleDateFormat类学习总结
qq_43956404的博客
09-06 342
日期类的一些使用方法
Java 中SimpleDateFormat类的使用
路宇的博客
01-10 743
SimpleDateFormat类的介绍 SimpleDateFormat类是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。 日期和时间格式由日期和时间模式字符串指定，在日期和时间模式字符串中，从“A” 到 “Z” 以及从“a” 到 “z” 引号的字母被解释为表示日期或时间字符串的组件的模式字母。 常用的模式字母对应关系如下： y 年 M 月 d 日 H 时 m 分 s 秒 SimpleDateFormat类的构造方法 SimpleDateFormat():使用默认模式和日期格式 Simpl
java学习路线总结.doc
11-12
- **日期和时间**：使用Date和SimpleDateFormat处理日期格式化，了解Calendar类的使用。 - **Java新特性**：学习Java 8及以上版本的新特性，如Lambda表达式、Stream API等。 **第五阶段：集合框架** - **集合概念**...
Java 实例 - 格式化时间SimpleDateFormat使用源代码-详细教程.zip
08-07
这个详细教程将引导你了解如何有效地使用`SimpleDateFormat`类。以下是关于`SimpleDateFormat`的一些核心知识点： 1. **类介绍**： `SimpleDateFormat`是`java.text.SimpleDateFormat`类的一个实例，它实现了`...
Android学习教程之日历库使用（15）
01-04
本教程为大家分享了Android日历库的使用方法，供大家参考，具体内容如下 MainActivity.java代码: package siso.weekv; import android.content.Intent; import android.support.v7.app.AppCompatActivity; import ...
Java学习路线：day21
01-21
`)SimpleDateFormat的使用SimpleDateFormat的练习Calendar日历类的使用JDK8中日期时间API的介绍LocalDate、LocalTime、LocalDateTime的使用Instant类的使用DateTimeFormatter的使用其它日期时间相关API的使用参考：...
使用EntityFramework8的学习和开发过程中一些经验
最新发布
morsth的博客
08-03 312
本篇文章主要记录自己在EF8的学习和使用过程中的碰到一些坑和自己琢磨的一些解决问题的方法以及过程。
学习硬件测试04：触摸按键+PWM 驱动蜂鸣器+数码管（P62~P67、P71、P72）
Xuexi_touteng的博客
07-31 357
Qutput compare preload 输出比较预加载：使能（可以改变占空比，而不是固定占空比）极速模式：关闭CH 极性：高（小于 CCR 的状态）状态：重置。
明确工作目标学习稿：计算技术体系的发展方向
weixin_45770491的博客
08-03 470
C体系”狭义上指我国构建处理器生态的第三条道路及其技术体系。
(学习总结10)C++类和对象1
瞌睡不来的博客
08-02 702
C++类和对象总结1
自定义日期格式：使用SimpleDateFormat
"这篇教程主要关注的是日期数据的定制格式，使用Java的`SimpleDateFormat`和`DateFormat`类来实现。教程属于第八课基于文本的应用，涵盖了多种编程概念，包括字符串处理、数学运算、大数据计算、时间处理、泛型、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值