疑惑，测试SimpleDateFormat并发的代码执行结果很奇怪。。。

最新推荐文章于 2022-12-18 12:52:35 发布
最新推荐文章于 2022-12-18 12:52:35 发布
阅读量327 收藏
点赞数
分类专栏： 高并发 java 文章标签： SimpleDateFormat java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35039122/article/details/80172714
版权

前几天工作中，遇到一个并发环境下有人写了SimpleDateFormat的场景，印象中这个是不能支持多线程的，应该使用ThreadLocal作为每个线程局部变量使用，今天有空，试了下SimpleDateFormat多线程使用，代码如下：

/**
 * TestDateFormat.java
 * zhm.test.dateFormat
 * 2018年5月2日下午9:02:07
 *
 */
package zhm.test.dateFormat;

import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Random;

/**
 * @author zhuheming TestDateFormat 2018年5月2日下午9:02:07
 */
public class TestDateFormat {

    public static TestDateFormat tdf = null;

    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

    public static void main(String[] args) {
        tdf = new TestDateFormat();
        for (int i = 1; i <= 9; i++) {

            Thread th = new Thread(new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        Random r = new Random();
                        int k = r.nextInt(100);

                        int randomSwitch = k % 3;

                        Calendar c = Calendar.getInstance();
                        c.add(Calendar.DATE, k);
                        try {
                            Thread.sleep(100);
                            switch (randomSwitch) {
                            case 0:
                                String s1 = c.get(Calendar.YEAR) + "-"
                                        + TestDateFormat.formatNumber((c.get(Calendar.MONTH) + 1)) + "-"
                                        + TestDateFormat.formatNumber((c.get(Calendar.DAY_OF_MONTH)));
                                Date date1 = tdf.printDateFormat(s1);
                                String d1 = new Timestamp(date1.getTime()).toString();
                                d1 = d1.substring(0,d1.indexOf(" "));
                                if(!s1.equals(d1)){
                                    System.out.println(s1+"     "+d1);
                                }
                                break;
                            case 1:
                                String s2 = c.get(Calendar.YEAR) + "-"
                                        + TestDateFormat.formatNumber((c.get(Calendar.MONTH) + 1)) + "-"
                                        + TestDateFormat.formatNumber((c.get(Calendar.DAY_OF_MONTH)));
                                Date date2 = TestDateFormat.printStaticDateFormat(s2);
                                String d2 = new Timestamp(date2.getTime()).toString();
                                d2 = d2.substring(0,d2.indexOf(" "));
                                if(!s2.equals(d2)){
                                    System.out.println(s2+"     "+d2);
                                }
                                break;
                            case 2:
                                String s = c.get(Calendar.YEAR) + "-"
                                        + TestDateFormat.formatNumber((c.get(Calendar.MONTH) + 1)) + "-"
                                        + TestDateFormat.formatNumber((c.get(Calendar.DAY_OF_MONTH)));
                                Date date3 = tdf.printReferenceDateFormat(s);
                                String d3 = new Timestamp(date3.getTime()).toString();
                                d3 = d3.substring(0,d3.indexOf(" "));
                                if(!s.equals(d3)){
                                    System.out.println(s+"     "+d3);
                                }
                                break;
                            default:
                                return;

                            }
                        } catch (Exception e) {

                        }
                    }
                }
            });
            th.start();
            try {
                th.join();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

    public Date printReferenceDateFormat(String str) {
        System.out.println("get the ReferenceDateFormat:" + sdf);
        try {
            return sdf.parse(str);
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return null;
        }
    }

    public static Date printStaticDateFormat(String str) {
        SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd");
        System.out.println("get static method the SimpleDateFormat:" + df1);
        try {
            return df1.parse(str);
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return null;
        }
    }

    public Date printDateFormat(String str) {
        SimpleDateFormat df2 = new SimpleDateFormat("yyyy-MM-dd");

        try {

            System.out.println("get the SimpleDateFormat:" + df2);
            return df2.parse(str);
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return null;
        }
    }

    private static String formatNumber(int n) {
        String s = "0" + n;
        return s.substring(s.length() - 2);
    }
}

按照设想，应该是sdf打印出的对象是同一个，后面两个打印出的对象因为每次需要新建对象，打印出来的都不相同才对。

但是结果如下：
get static method the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get static method the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get the ReferenceDateFormat:java.text.SimpleDateFormat@f67a0200
get the ReferenceDateFormat:java.text.SimpleDateFormat@f67a0200
get static method the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get static method the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get the ReferenceDateFormat:java.text.SimpleDateFormat@f67a0200
get the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get the ReferenceDateFormat:java.text.SimpleDateFormat@f67a0200
get the ReferenceDateFormat:java.text.SimpleDateFormat@f67a0200
get the ReferenceDateFormat:java.text.SimpleDateFormat@f67a0200
get the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get static method the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get static method the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get static method the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get static method the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get static method the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get static method the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get the ReferenceDateFormat:java.text.SimpleDateFormat@f67a0200
get the ReferenceDateFormat:java.text.SimpleDateFormat@f67a0200
get the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get the ReferenceDateFormat:java.text.SimpleDateFormat@f67a0200
get the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get static method the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get the ReferenceDateFormat:java.text.SimpleDateFormat@f67a0200
get the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get static method the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get static method the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get static method the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get the ReferenceDateFormat:java.text.SimpleDateFormat@f67a0200
get the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get static method the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get the ReferenceDateFormat:java.text.SimpleDateFormat@f67a0200
get the SimpleDateFormat:java.text.SimpleDateFormat@f67a0200
get the ReferenceDateFormat:java.text.SimpleDateFormat@f67a0200

对象居然是同一个，这就很奇怪了，谁知道原因呢？

看了下SimpleDateFormat源码，里面根据pattern从static的concurrentHashMap中取对应的信息，对于不同的SimpleDateFormat对象，只要定义的格式相同，pattern对象是同一个。

后来换了种方式测试，直接粗暴的写五个进程跑，证明确实会出现并发问题：
2018-12-25 2203-01-24
2498-10-10 2203-01-24
2018-12-25 0001-10-10
2998-01-02 3004-12-01
1698-09-22 3004-12-01
且只有共享的static会有这个问题，去掉共享的static，那么在方法内调用的就不存在并发问题。


/**
 * TestDateFormat.java
 * zhm.test.dateFormat
 * 2018年5月2日下午9:02:07
 *
 */
package zhm.test.dateFormat;

import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Random;

/**
 * @author zhuheming TestDateFormat 2018年5月2日下午9:02:07
 */
public class TestDateFormat {

    public static TestDateFormat tdf = null;

    //SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

    public static void main(String[] args) {
        tdf = new TestDateFormat();


            Thread th1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        Random r = new Random();
                        int k = r.nextInt(100);

                        int randomSwitch = k % 3;

                        //Calendar c = Calendar.getInstance();
                        //c.add(Calendar.DATE, k);
                        try {
                            Thread.sleep(100);
                            switch (randomSwitch) {
                            case 0:
                                String s1 = "2018-12-25";
                                String d1 = tdf.printDateFormat(s1);
                                //String d1 = new Timestamp(date1.getTime()).toString();
                                //d1 = d1.substring(0,d1.indexOf(" "));
                                if(!s1.equals(d1)){
                                    System.out.println(s1+"     "+d1);
                                }
                                break;
                            case 1:
                                String s2 = "2018-12-25";
                                String d2 = TestDateFormat.printStaticDateFormat(s2);
                                //String d2 = new Timestamp(date2.getTime()).toString();
                                //d2 = d2.substring(0,d2.indexOf(" "));
                                if(!s2.equals(d2)){
                                    System.out.println(s2+"     "+d2);
                                }
                                break;
                            case 2:
                                String s ="2018-12-25";
                                String d3 = tdf.printReferenceDateFormat(s);
                                //String d3 = new Timestamp(date3.getTime()).toString();
                                //d3 = d3.substring(0,d3.indexOf(" "));
                                if(!s.equals(d3)){
                                    System.out.println(s+"     "+d3);
                                }
                                break;
                            default:
                                return;

                            }
                        } catch (Exception e) {

                        }
                    }
                }
            });

    Thread th2 = new Thread(new Runnable() {
        @Override
        public void run() {
            while (true) {
                Random r = new Random();
                int k = r.nextInt(3);
                int randomSwitch = k % 3;

                //Calendar c = Calendar.getInstance();
                //c.add(Calendar.DATE, k);
                try {
                    Thread.sleep(100);
                    switch (randomSwitch) {
                    case 0:
                        String s1 = "1998-11-12";
                        String d1 = tdf.printDateFormat(s1);
                        //String d1 = new Timestamp(date1.getTime()).toString();
                        //d1 = d1.substring(0,d1.indexOf(" "));
                         if(!s1.equals(d1)){
                            System.out.println(s1+"     "+d1);
                         }
                        break;
                    case 1:
                        String s2 = "1998-11-12";
                        String d2 = TestDateFormat.printStaticDateFormat(s2);
                        //String d2 = new Timestamp(date2.getTime()).toString();
                        //d2 = d2.substring(0,d2.indexOf(" "));
                        if(!s2.equals(d2)){
                            System.out.println(s2+"     "+d2);
                        }
                        break;
                    case 2:
                        String s = "1998-11-12";
                        String d3 = tdf.printReferenceDateFormat(s);
                        //String d3 = new Timestamp(date3.getTime()).toString();
                        //d3 = d3.substring(0,d3.indexOf(" "));
                        if(!s.equals(d3)){
                            System.out.println(s+"     "+d3);
                        }
                        break;
                    default:
                        return;

                    }
                } catch (Exception e) {

                }
            }
        }
    });

    Thread th3 = new Thread(new Runnable() {
        @Override
        public void run() {
            while (true) {
                Random r = new Random();
                int k = r.nextInt(3);
                int randomSwitch = k % 3;

                //Calendar c = Calendar.getInstance();
                //c.add(Calendar.DATE, k);
                try {
                    Thread.sleep(100);
                    switch (randomSwitch) {
                    case 0:
                        String s1 = "1698-09-22";
                        String d1 = tdf.printDateFormat(s1);
                        //String d1 = new Timestamp(date1.getTime()).toString();
                        //d1 = d1.substring(0,d1.indexOf(" "));
                         if(!s1.equals(d1)){
                            System.out.println(s1+"     "+d1);
                         }
                        break;
                    case 1:
                        String s2 = "1698-09-22";
                        String d2 = TestDateFormat.printStaticDateFormat(s2);
                        //String d2 = new Timestamp(date2.getTime()).toString();
                        //d2 = d2.substring(0,d2.indexOf(" "));
                        if(!s2.equals(d2)){
                            System.out.println(s2+"     "+d2);
                        }
                        break;
                    case 2:
                        String s = "1698-09-22";
                        String d3 = tdf.printReferenceDateFormat(s);
                        //String d3 = new Timestamp(date3.getTime()).toString();
                        //d3 = d3.substring(0,d3.indexOf(" "));
                        if(!s.equals(d3)){
                            System.out.println(s+"     "+d3);
                        }
                        break;
                    default:
                        return;

                    }
                } catch (Exception e) {

                }
            }
        }
    });

    Thread th4 = new Thread(new Runnable() {
        @Override
        public void run() {
            while (true) {
                Random r = new Random();
                int k = r.nextInt(3);
                int randomSwitch = k % 3;

                //Calendar c = Calendar.getInstance();
                //c.add(Calendar.DATE, k);
                try {
                    Thread.sleep(100);
                    switch (randomSwitch) {
                    case 0:
                        String s1 = "2498-10-10";
                        String d1 = tdf.printDateFormat(s1);
                        //String d1 = new Timestamp(date1.getTime()).toString();
                        //d1 = d1.substring(0,d1.indexOf(" "));
                         if(!s1.equals(d1)){
                            System.out.println(s1+"     "+d1);
                         }
                        break;
                    case 1:
                        String s2 = "2498-10-10";
                        String d2 = TestDateFormat.printStaticDateFormat(s2);
                        //String d2 = new Timestamp(date2.getTime()).toString();
                        //d2 = d2.substring(0,d2.indexOf(" "));
                        if(!s2.equals(d2)){
                            System.out.println(s2+"     "+d2);
                        }
                        break;
                    case 2:
                        String s = "2498-10-10";
                        String d3 = tdf.printReferenceDateFormat(s);
                        //String d3 = new Timestamp(date3.getTime()).toString();
                        //d3 = d3.substring(0,d3.indexOf(" "));
                        if(!s.equals(d3)){
                            System.out.println(s+"     "+d3);
                        }
                        break;
                    default:
                        return;

                    }
                } catch (Exception e) {

                }
            }
        }
    });

    Thread th5 = new Thread(new Runnable() {
        @Override
        public void run() {
            while (true) {
                Random r = new Random();
                int k = r.nextInt(3);
                int randomSwitch = k % 3;

                //Calendar c = Calendar.getInstance();
                //c.add(Calendar.DATE, k);
                try {
                    Thread.sleep(100);
                    switch (randomSwitch) {
                    case 0:
                        String s1 = "2998-01-02";
                        String d1 = tdf.printDateFormat(s1);
                        //String d1 = new Timestamp(date1.getTime()).toString();
                        //d1 = d1.substring(0,d1.indexOf(" "));
                         if(!s1.equals(d1)){
                            System.out.println(s1+"     "+d1);
                         }
                        break;
                    case 1:
                        String s2 = "2998-01-02";
                        String d2 = TestDateFormat.printStaticDateFormat(s2);
                        //String d2 = new Timestamp(date2.getTime()).toString();
                        //d2 = d2.substring(0,d2.indexOf(" "));
                        if(!s2.equals(d2)){
                            System.out.println(s2+"     "+d2);
                        }
                        break;
                    case 2:
                        String s = "2998-01-02";
                        String d3 = tdf.printReferenceDateFormat(s);
                        //String d3 = new Timestamp(date3.getTime()).toString();
                        //d3 = d3.substring(0,d3.indexOf(" "));
                        if(!s.equals(d3)){
                            System.out.println(s+"     "+d3);
                        }
                        break;
                    default:
                        return;

                    }
                } catch (Exception e) {

                }
            }
        }
    });
    th1.start();
    th2.start();
    th3.start();
    th4.start();
    th5.start();
    try {
        th1.join();
        th2.join();
        th3.join();
        th4.join();
        th5.join();
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}


    public String printReferenceDateFormat(String str) {
        //Date dt= sdf.parse(str);
        //return sdf.format(dt);
        return str;
    }

    public static String printStaticDateFormat(String str) {
        SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd");
        //System.out.println("get static method the SimpleDateFormat:" + df1);
        try {
            Thread.sleep(100);
            Date dt=df1.parse(str);
            str=df1.format(dt);
            //df1.getCalendar().clear();
            return str;
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return null;
        }
    }

    public String printDateFormat(String str) {
        SimpleDateFormat df2 = new SimpleDateFormat("yyyy-MM-dd");

        try {
            Thread.sleep(100);
            Date dt=df2.parse(str);
            str=df2.format(dt);
            //df2.getCalendar().clear();
            //System.out.println("get the SimpleDateFormat:" + df2);
            return str;
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return null;
        }
    }

}

那么只有最后一个问题了，为什么看起来是同一个对象呢：

大家都知道system.out.prinl(object)其实是打印的String.valueof的对象值；valueof是什么呢？
public static String valueOf(Object obj) {
return (obj == null) ? “null” : obj.toString();
}
就是obj的toString的值，那么obj的toString由Object类定义，各个子类自己重写，在Object中，定义如下：
public String toString() {
return getClass().getName() + “@” + Integer.toHexString(hashCode());
}

显然就是Object的hashCode的十六进制数值，那么在SimpleDateFormat中hashcode方法是如何呢？
public int hashCode()
{
return pattern.hashCode();
// just enough fields for a reasonable distribution
}
从这里可以看出，SimpleDateFormat没有返回自己的对象的地址等，而是返回了pattern的hashcode，前面已经说过，输入的格式相同，pattern是同一个，所以，此处SimpleDateFormat对象打印出来是同一个，但其实不是。

每次看源码，带着疑问看源代码，总是能让人收获很多，大家共勉。。。

zhm_icbchz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java时间格式化----java.text.SimpleDateFormat
QuinnNorris的博客
01-13 1万+
转载请注明本地址：http://blog.csdn.net/QuinnNorris/article/details/ java.text.SimpleDateFormat在java中我们一般用来格式化的类在text包中的SimpleDateFormat，这个类在对事件的处理上可以算是专业选手，向上追根，SimpleDateFormat类继承于DateFormat，DateFormat继承于Forma
java.text.dateformat_java.text.SimpleDateFormat使用介绍
weixin_39674978的博客
02-25 654
java.text.SimpleDateFormat的使用java.lang.Object|+----java.text.Format|+----java.text.DateFormat|+----java.text.SimpleDateFormat---------------------------------------------------------------------------...
SimpleDateFormat并发隐患及其解决-Joda-Time
arthur.dy.lee的专栏
08-24 4288
Joda-Time替换SimpleDateFormat并发隐患
高并发之——SimpleDateFormat类的线程安全问题和解决方案
热门推荐
冰河的专栏
02-19 1万+
首先问下大家：你使用的SimpleDateFormat类还安全吗？带着这个问题再来看本文。 提起SimpleDateFormat类，想必做过Java开发的童鞋都不会感到陌生。没错，它就是Java中提供的日期时间的转化类。这里，为什么说SimpleDateFormat类有线程安全问题呢？有些小伙伴可能会提出疑问：我们生产环境上一直在使用SimpleDateFormat类来解析和格式化日期和时间类型...
java.text.SimpleDateFormat 日期自定义格式转换类
1234的博客
06-05 1万+
SimpleDateFormat日期的自定义格式转换类，这个挺好用。首先需要了解一些日期的代表符号： yyyy    四位年 yy       两位年 MM    月份  始终两位 M       月份      dd      始终两位日期 d        日期 HH    24小时制  始终两位 H       24小时制 hh     12小时制  始终两位 h       12小时制 m...
Java时间日期
ABC的专栏
05-14 792
简单的DateFormat格式化编码 时间模式字符串用来指定时间格式。在此模式中，所有的ASCII字母被保留为模式字母，定义如下： 字母 描述 示例 G 纪元标记 AD y 四位年份 2001 M 月份 July or 07 d 一个月的日期 10
Java在并发环境中SimpleDateFormat多种解决方案
08-18
Java在并发环境中SimpleDateFormat多种解决方案 Java在并发环境中使用SimpleDateFormat时，可能会遇到线程安全问题。下面将介绍六种解决方案来解决这个问题。 方法一：使用局部变量 在需要执行格式化的地方都新建...
java代码-SimpleDateFormat YYYY解析问题
07-15
在Java编程语言中，`SimpleDateFormat` 是一个非常重要的日期时间格式化类，它允许我们按照自定义的模式来解析和格式化日期。在标题提到的"SimpleDateFormat YYYY解析问题"中，通常指的是使用 `YYYY` 作为日期模式时...
JAVA使用SimpleDateFormat类表示时间代码实例
08-19
JAVA 使用 SimpleDateFormat 类表示时间代码实例 JAVA 中的日期和时间处理是非常重要的，特别是在程序开发中，经常需要处理日期和时间的相关数据。在 JAVA 中，我们可以使用 java.util 包中的 Date 类来获取当前...
java代码-SimpleDateFormat YYYY显示问题
07-15
在描述中提到的问题“java代码-SimpleDateFormat YYYY显示问题”可能指的是在使用`SimpleDateFormat`时遇到了与年份表示相关的异常或者不符合预期的结果。 首先，让我们理解一下`SimpleDateFormat`中的"YYYY"和...
Java中SimpleDateFormat日期格式转换详解及代码示例
08-28
Java中SimpleDateFormat日期格式转换详解及代码示例 SimpleDateFormat是Java中处理日期格式转换的类，继承于DateFormate。它提供了多种格式定义，能够将日期类型时间转换为字符串类型时间，反之亦然。 ...
关于java.text.SimpleDateFormat年月日的格式在Javaapi中的解释
yyf960126的博客
05-08 1713
SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -&gt; 文本）、解析（文本 -&gt; 日期）和规范化。 SimpleDateFormat 使得可以选择任何用户定义的日期-时间格式的模式。但是，仍然建议通过 DateFormat 中的 getTimeInstance、getDateInstance 或 getDateTimeIn...
java.text下的SimpleDateFormat类
Lazyafei's Blog
08-15 831
开发中经常会用到格式化的时间，SimpleDateFormat类就可以轻松过解决这些问题，引用Oracle官方文档介绍： SimpleDateFormat is a concrete class for formatting and parsing dates in a locale-sensitive manner. It allows for formatting (date -&gt; t...
java SimpleDateFormat并发问题
小十木的博客
07-20 2957
SimpleDateFormat 的并发安全问题 很多人为了提高性能，会把 private static final SimpleDateFormat simpleDateFormat=new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”); 作为全局变量来写代码；这样写代码会有并发问题，因为 在调用format 或者parse等方法的时候，该类的对象会用到全...
共享SimpleDateFormat的并发问题
LXYDSF的博客
12-18 1316
共享SimpleDateFormat的并发问题
SimpleDateFormat 并发引发的错误
zhuxh8610的专栏
11-01 1045
一、背景：正式环境偶尔数据查询不出来，而且有时候即使查询出来数据也是错误，很是头疼！多次测试又还原不了这种场景，只有通过后台日志一点点分析，终于抓到一次报错，信息如下： java.lang.NumberFormatException: For input string: ""     at java.lang.NumberFormatException.forInputString(Number...
SimpleDateFormat线程安全测试用例
u014046563的专栏
04-08 207
众所周知 SimpleDateFormat在多线程环境下是不安全的，具体可以参考https://blog.csdn.net/csdn_ds/article/details/72984646，其本质原因是多线程存在共享变量，导致数据处理结果不一致甚至错误，具体的解决方案： （1）将共享变量设置为局部变量，每个线程私有化； （2）在使用共享变量的时候进行加锁处理，虽然可以解决问题，但是效率低下； ...
SimpleDateFormat:日期格式化产生奇怪的日期数据
进击的码字猴
12-17 692
日期格式化产生奇怪的日期数据问题现象：查找原因解决办法测试及验证方案 问题现象： 作为一名有想法的设计师（不，是程序员），为了方便公司的平台应用查看所有的网络请求数据以及PDA(大砖头掌机)的操作数据，我将所有的请求及返回数据等等等…巴拉巴拉的数据（当然只有debug模式才存储），都保存到了手机的固定目录下，并使用****+****+*****+日期.log 进行保存。想法很不错吧，哈哈哈（其实也就那样儿…） BUT：却偶然被测试发现一个问题，有时日志文件会出现2020001217.log这种非主流（sb）
高并发下的SimpleDateFormat
半生苦涩半生酸的博客
01-13 2776
废话不多说，先上代码 package z.farrell.framework.utils; import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.concurrent.ExecutorService; import jav
将java的SimpleDateFormat方法转为对等的c#代码
最新发布
06-06
Java 中的 SimpleDateFormat 类可以使用 C# 中的 DateTime 类来实现相同的功能。以下是 Java 中使用 SimpleDateFormat 格式化日期和时间的示例： ``` SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Date date = new Date(); String formattedDate = dateFormat.format(date); System.out.println(formattedDate); ``` 在 C# 中，可以使用 DateTime 类的 ToString 方法来格式化日期和时间。以下是将上述 Java 代码转换为 C# 代码的示例： ``` DateTime date = DateTime.Now; string formattedDate = date.ToString("yyyy-MM-dd HH:mm:ss"); Console.WriteLine(formattedDate); ``` 请注意，C# 中的日期时间操作与 Java 有所不同，因此在进行转换时需要注意。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值