java多线程_SimpleDateFormat类线程不安全分析

最新推荐文章于 2024-07-20 13:08:48 发布
最新推荐文章于 2024-07-20 13:08:48 发布
阅读量740 收藏 1
点赞数
分类专栏： JAVA多线程 文章标签： java jvm 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dongkang123456/article/details/128943585
版权

SimpleDateFormat 使用说明

在JAVA的江湖世界，虽然日期转换工具类如此纷繁复杂；但是作为初入世事的JAVA程序员，了解到的第一款日期格式化武器毫无疑问是 “SimpleDateFormat”; 毫无疑问的是 SimpleDateFormat 帮助我们解决了太多太多的日期转换问题。在此向它致敬；

也许在某个深夜，你在研读一些JAVA的经典著作，忽然一行文字引入眼帘——“SimpleDateFormat 线程不安全”，你不禁打了个寒颤，my god。或许，你上线了无数个不安全的 “SimpleDateFormat”，然而它并没有对你的生产环境造成任何实质性的影响。如果是这样，我想你是幸运的，因为你的系统的并发能力还不至于重现 “SimpleDateFormat” 的不安全的场景。

然而作为一个有志的JAVA程序员。你必须要避免任何导致程序异常的情况发生。

所以我们要做的是：
第一步：重现 SimpleDateFormat 多线程问题。
第二步： why? SimpleDateFormat 为什么不安全。
第三步：怎么解决这个问题。

ok，现在让我们来开始探讨这个问题。

SimpleDateFormat 多线程问题重现

好的，我们通过线程池构建一个多线程访问环境，来看看SimpleDateFormat究竟会发生那些问题？

代码如下：

package com.java.thread.demo003;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 *
 * SimpleDateFormat 线程不安全问题重现
 * */
public class Demo003_a {

    private static SimpleDateFormat simpleDateFormat
            =  new SimpleDateFormat("yyyy-MM-dd");

    public static void main(String[] args) {
        ExecutorService executors = Executors.newCachedThreadPool();
        for(int i=0; i< 10; i++){
            executors.execute(()->{

                try {
                    simpleDateFormat.parse("2023-02-08");
                    System.out.println(Thread.currentThread().getName() + " 日期格式化成功");
                } 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);
                }

            });
        }

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executors.shutdown();
        System.out.println("所有线程格式化日期成功!!");
    }
}

运行结果如下所示，当然失败的姿势多种多样。如果你运气好的话，也有可能运行成功。

"D:\Program Files\Java\jdk1.8.0_181\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2020.2.3\lib\idea_rt.jar=49240:D:\Program Files\JetBrains\IntelliJ IDEA 2020.2.3\bin" -Dfile.encoding=UTF-8 -classpath "D:\Program Files\Java\jdk1.8.0_181\jre\lib\charsets.jar;D:\Program Files\Java\jdk1.8.0_181\jre\lib\deploy.jar;D:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\access-bridge-64.jar;D:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\cldrdata.jar;D:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\dnsns.jar;D:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\jaccess.jar;D:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\jfxrt.jar;D:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\localedata.jar;D:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\nashorn.jar;D:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunec.jar;D:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunjce_provider.jar;D:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunmscapi.jar;D:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunpkcs11.jar;D:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\zipfs.jar;D:\Program Files\Java\jdk1.8.0_181\jre\lib\javaws.jar;D:\Program Files\Java\jdk1.8.0_181\jre\lib\jce.jar;D:\Program Files\Java\jdk1.8.0_181\jre\lib\jfr.jar;D:\Program Files\Java\jdk1.8.0_181\jre\lib\jfxswt.jar;D:\Program Files\Java\jdk1.8.0_181\jre\lib\jsse.jar;D:\Program Files\Java\jdk1.8.0_181\jre\lib\management-agent.jar;D:\Program Files\Java\jdk1.8.0_181\jre\lib\plugin.jar;D:\Program Files\Java\jdk1.8.0_181\jre\lib\resources.jar;D:\Program Files\Java\jdk1.8.0_181\jre\lib\rt.jar;D:\study_note\Code_JavaStudy\Java\target\classes;D:\repository\org\antlr\antlr4-runtime\4.10.1\antlr4-runtime-4.10.1.jar;D:\repository\org\openjdk\jol\jol-core\0.14\jol-core-0.14.jar;D:\repository\org\projectlombok\lombok\1.18.0\lombok-1.18.0.jar" com.java.thread.demo003.Demo003_a
pool-1-thread-1 解析失败
pool-1-thread-2 日期格式化成功
pool-1-thread-3 解析失败
pool-1-thread-4 日期格式化成功
pool-1-thread-5 日期格式化成功
pool-1-thread-6 日期格式化成功
pool-1-thread-7 日期格式化成功
pool-1-thread-8 日期格式化成功
pool-1-thread-9 日期格式化成功
pool-1-thread-10 日期格式化成功
java.lang.NumberFormatException: For input string: "2200022333.E2200022333E44"
	at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:2043)
	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:2089)
	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.java.thread.demo003.Demo003_a.lambda$main$0(Demo003_a.java:24)
	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)
java.lang.NumberFormatException: For input string: "2200022333.E2200022333E44"
	at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:2043)
	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:2089)
	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.java.thread.demo003.Demo003_a.lambda$main$0(Demo003_a.java:24)
	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)

Process finished with exit code 1

为什么parse方法解析的对象不是合法的日期字符串类型，而是一些奇奇怪怪的东西了？为了找到相应的原因，我们必须进入到SimpleDateFormat的源代码来进行分析。

SimpleDateFormat 多线程问题分析

首先我们进入SimpleDateFormat的parse方法,然后查看parse()接近最后的部分

@Override
public Date parse(String text, ParsePosition pos)
{
    Date parsedDate;
    try {
        parsedDate = calb.establish(calendar).getTime();
        // If the year value is ambiguous,
        // then the two-digit year == the default start year
        if (ambiguousYear[0]) {
            if (parsedDate.before(defaultCenturyStart)) {
                parsedDate = calb.addYear(100).establish(calendar).getTime();
            }
        }
    }
    // An IllegalArgumentException will be thrown by Calendar.getTime()
    // if any fields are out of range, e.g., MONTH == 17.
    catch (IllegalArgumentException e) {
        pos.errorIndex = start;
        pos.index = oldStart;
        return null;
    }

    return parsedDate;
}

最后的返回值是通过 calb.establish(calendar).getTime() 获取到的;

接下来我们分析一下CalendarBuilder的这个方法

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;
    }

    cal.clear();
    // Set the fields from the min stamp to the max stamp so that
    // the field resolution works in the Calendar.
    for (int stamp = MINIMUM_USER_STAMP; stamp < nextStamp; stamp++) {
        for (int index = 0; index <= maxFieldIndex; index++) {
            if (field[index] == stamp) {
                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;
}

可以看到，在establish中先调用了cal.clear(),后调用了cal.set(),cal 是Calendar的对象，是一个
成员实例。

不幸的是Calendar是线程不安全的，当多个线程同时操作一个SimpleDateFormat的时候，会引起cal的混乱。

SimpleDateFormat 多线程问题解决

从上面我们验证的SimpleDateFormat的线程问题，并且简单的分析了造成线程不安全问题的原因。

那么我们如何在代码编写工作中去规避这个问题了？

当然解决问题的方式永远是多种多样的，下面只是简单的列举了众多解决方法中的几种，如果你有更加好的解决办法，请及时留言，我将感谢万分!!!

局部变量法

package com.java.thread.demo003;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 *
 * SimpleDateFormat 线程不安全问题重现
 * */
public class Demo003_b {


    public static void main(String[] args) {
        ExecutorService executors = Executors.newCachedThreadPool();
        for(int i=0; i< 10; i++){
            executors.execute(()->{

                SimpleDateFormat simpleDateFormat
                        =  new SimpleDateFormat("yyyy-MM-dd");
                try {
                    simpleDateFormat.parse("2023-02-08");
                    System.out.println(Thread.currentThread().getName() + " 日期格式化成功");
                } 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);
                }

            });
        }

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executors.shutdown();
        System.out.println("所有线程格式化日期成功!!");
    }
}

很显然这样能够规避 SimpleDateFormat 线程不安全的问题，但是这对于高并发场景并不友好；因为其会创建很多的SimpleDateFormat对象。

synchronized 锁方式

package com.java.thread.demo003;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 *
 * SimpleDateFormat 线程不安全问题重现
 * */
public class Demo003_c {

    private static SimpleDateFormat simpleDateFormat
            =  new SimpleDateFormat("yyyy-MM-dd");

    public static void main(String[] args) {
        ExecutorService executors = Executors.newCachedThreadPool();
        for(int i=0; i< 10; i++){
            executors.execute(()->{

                try {
                    synchronized (simpleDateFormat) {
                        simpleDateFormat.parse("2023-02-08");
                    }
                    System.out.println(Thread.currentThread().getName() + " 日期格式化成功");
                } 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);
                }

            });
        }

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executors.shutdown();
        System.out.println("所有线程格式化日期成功!!");
    }
}

这种方式虽然不用像局部变量法那样创建很多的对象，但是会造成其它线程的等待，同样对高并发场景不太友好。

ThreadLocal方式

package com.java.thread.demo003;

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

/**
 *
 * SimpleDateFormat 线程不安全问题重现
 * */
public class Demo003_d {

    private static final ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>(){
        @Override
        protected DateFormat initialValue() {
            return new SimpleDateFormat("yyyy-MM-dd");
        }
    };

    public static void main(String[] args) {
        ExecutorService executors = Executors.newCachedThreadPool();
        for(int i=0; i< 10; i++){
            executors.execute(()->{

                try {
                    threadLocal.get().parse("2023-02-08");
                    System.out.println(Thread.currentThread().getName() + " 日期格式化成功");
                } 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);
                }

            });
        }

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executors.shutdown();
        System.out.println("所有线程格式化日期成功!!");
    }
}

使用ThreadLocal存储每个线程拥有的SimpleDateFormat的对象的副本，能够有效的避免线程不安全的问题。

这种方式运行效率比较高，推荐在高并发业务场景使用。

DateTimeFormatter方式

DateTimeFormatter 是java8新提供的日期格式化武器；是线程安全的，且适合高并发场景。

package com.java.thread.demo003;

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

/**
 *
 * SimpleDateFormat 线程不安全问题重现
 * */
public class Demo003_e {


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

    public static void main(String[] args) {
        ExecutorService executors = Executors.newCachedThreadPool();
        for(int i=0; i< 10; i++){
            executors.execute(()->{

                try {
                    LocalDate.parse("2023-02-08",formatter);
                    System.out.println(Thread.currentThread().getName() + " 日期格式化成功");
                } catch (Exception e) {
                    System.out.println(Thread.currentThread().getName() + " 解析失败");
                    e.printStackTrace();
                    System.exit(1);
                }

            });
        }

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executors.shutdown();
        System.out.println("所有线程格式化日期成功!!");
    }
}

参考

<<深入理解高并发编程>>

桃仙人
关注
专栏目录
SimpleDateFormat多线程问题
SweetTool的专栏
05-04 496
四月份在优化一个功能时候，尝试把Date和SimpleDateFormat封装在class中，然后统一format和parse解析，以此避免重复new对象节省重复申请内存。于是就遇到了一个坑——经常出现莫名其妙的日期，打印出来时候甚至有0650年的日期，唐朝啊，难道计算机给我玩穿越？！，大家都知道一般日期是1970-01-01开始的，要么再早一些事1900-01-01开始的，不会再早...
Java-SimpleDateFormat线程安全问题
FromZeroJiYuan的博客
11-22 3138
文章目录SimpleDateFormat使用示例SimpleDateFormat问题线程不安全解决方案使用局部变量使用全局变量 & 操作加锁使用ThreadLocal进行线程隔离JDK8-DateTimeFormatter用法 SimpleDateFormat java.text.SimpleDateFormat是常用的时间日期格式化和解析的Java类。 SimpleDateFormat支持到毫秒精度。 使用 SimpleDateFormat最常用的方法是格式化日期时间和解析日期时间。 publi
为什么SimpleDateFormat不是线程安全的？
niceyoo的博客
09-15 643
一、前言 日期的转换与格式化在项目中应该是比较常用的了，最近同事小刚出去面试实在是没想到被 SimpleDateFormat 给摆了一道… 面试官：项目中的日期转换怎么用的？SimpleDateFormat 用过吗？能说一下 SimpleDateFormat 线程安全问题吗，以及如何解决？ 同事小刚：用过的，平时就是在全局定义一个 static 的 SimpleDateFormat，然后在业务处理方法（controller）中直接使用，至于线程安全… 这个… 倒是没遇到过线程安全问题。 哎，面试官的考察点真
java的SimpleDateFormat线程不安全出问题了，虚竹教你多种解决方案_simpledateformat 漏洞
最新发布
2401_84264536的博客
07-20 779
就是要使用SimpleDateFormat对象进行format或parse时，再定义为局部变量。就能保证线程安全。//1、创建线程池//2、为线程池分配任务i < 10;i++) {//3、关闭线程池@Overridetry {System.out.println(Thread.currentThread().getName()+" 线程是否安全: "+dateString.equals(dateString2));
线程不安全的SimpleDateFormat
技术原始积累
12-14 223
8.5 SimpleDateFormat是线程不安全的SimpleDateFormat是Java提供的一个格式化和解析日期的工具类，日常开发中应该经常会用到，但是由于它是...
多线程下使用SimpleDateFormat
peng_huaiyang的博客
05-13 2655
一般情况下： 在日常开发中，我们会把SimpleDateFormat定义为一个静态变量，以此来避免频繁创建对象实例，但是在多线程的情况下，SimpleDateFormat实例就会被多个线程共享，会出现各种各样的问题。 解决方案： 1、使用synchronized，非常简单的解决了线程安全的问题，缺陷就是synchronized是重量级的，并发量大的时...
小编带你了解SimpleDateFormat-多线程问题
weixin_34008784的博客
09-05 203
SimpleDateFormat-多线程问题：　　SimpleDateFormat类在多线程环境下中处理日期，极易出现日期转换错误的情况import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Date; /** 线程类*/public class MyThread extends Th...
Java多线程环境下SimpleDateFormat类安全转换
08-25
"Java多线程环境下SimpleDateFormat类安全转换" 在Java多线程环境下，SimpleDateFormat类的使用可能会出现线程安全问题。本文主要介绍了Java多线程环境下SimpleDateFormat类的安全转换，通过示例代码详细介绍了如何...
Java SimpleDateFormat线程安全问题原理详解
08-19
Java SimpleDateFormat线程安全问题原理详解 Java SimpleDateFormat线程安全问题是Java开发中一个常见的问题。SimpleDateFormat是Java中一个常用的日期时间格式化类，但是它却存在线程安全问题。在多线程环境下，...
详解SimpleDateFormat的线程安全问题与解决方案
08-30
在Java编程中，`SimpleDateFormat`是一个常用的日期时间格式化工具类，但它的设计并不是线程安全的。本文将深入探讨`SimpleDateFormat`的线程安全问题及其解决方案。 ### 1. 线程安全问题的原因 `SimpleDateFormat...
SimpleDateFormat引发的多线程安全问题
探长々
08-23 445
是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。线程不安全也叫非线程安全，是指多线程执行中，程序的执行结果和预期的结果不符的情况就叫做线程不安全。
Java多线程：SimpleDateFormat
weixin_34337381的博客
09-24 99
一、SimpleDateFormat的线程安全问题 　　为什么SimpleDateFormat是线程不安全的？ 　　下面通过一个案例代码来说明 public class DateUtilTest { public static class TestSimpleDateFormatThreadSafe extends Thread { ...
高并发之——SimpleDateFormat类的线程安全问题和解决方案
热门推荐
冰河的专栏
02-19 1万+
首先问下大家：你使用的SimpleDateFormat类还安全吗？带着这个问题再来看本文。 提起SimpleDateFormat类，想必做过Java开发的童鞋都不会感到陌生。没错，它就是Java中提供的日期时间的转化类。这里，为什么说SimpleDateFormat类有线程安全问题呢？有些小伙伴可能会提出疑问：我们生产环境上一直在使用SimpleDateFormat类来解析和格式化日期和时间类型...
SimpleDateFormat导致的多线程问题
clamaa的专栏
10-18 259
  今天在跑压力测试的过程中，一个看似不可能出错的地方居然报错了，起因在于我们定义的DateUtil工具类，用于将日期进行合理的format以及parse，出现了多线程问题（在单线程时不会出错，只有压测过程中会出现错误）。   代码上分析，原来编写的DateUtil简直是漏洞百出，首先将SimpleDateFormat定义为static变量，这表明在JVM中仅存在一份：   ...
SimpleDateFormat线程安全问题及解决方案
巴黎有个小铁匠
03-19 4214
日常开发中，我们经常需要使用时间相关类，说到时间相关类，想必大家对SimpleDateFormat并不陌生。主要是用它进行时间的格式化输出和解析，挺方便快捷的，但是SimpleDateFormat并不是一个线程安全的类。在多线程情况下，会出现异常，想必有经验的小伙伴也遇到过。下面我们就来分析分析SimpleDateFormat为什么不安全？是怎么引发的？以及多线程下有那些SimpleDateFor...
SimpleDateFormat线程不安全
u013602859的博客
03-23 375
本文对SimpleDateFormat线程不安全原因进行分析，并提供了几种解决方案，其中对于Java8中新增的DateTImeFormat为何线程安全进行了简单介绍，如有问题欢迎留言
simpleDateFormat线程不安全
weixin_33717117的博客
12-04 143
simpleDateFormat是我们比较常用的日期转换类，但是它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值